001 /*
002 * Copyright 2010-2015 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.kotlin.resolve;
018
019 import com.google.common.collect.ImmutableMap;
020 import com.intellij.psi.PsiElement;
021 import org.jetbrains.annotations.NotNull;
022 import org.jetbrains.annotations.Nullable;
023 import org.jetbrains.annotations.ReadOnly;
024 import org.jetbrains.annotations.TestOnly;
025 import org.jetbrains.kotlin.cfg.TailRecursionKind;
026 import org.jetbrains.kotlin.descriptors.*;
027 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
028 import org.jetbrains.kotlin.name.FqName;
029 import org.jetbrains.kotlin.name.FqNameUnsafe;
030 import org.jetbrains.kotlin.psi.*;
031 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemCompleter;
032 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
033 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
034 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
035 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
036 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
037 import org.jetbrains.kotlin.resolve.scopes.receivers.Qualifier;
038 import org.jetbrains.kotlin.types.DeferredType;
039 import org.jetbrains.kotlin.types.KotlinType;
040 import org.jetbrains.kotlin.types.expressions.CaptureKind;
041 import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo;
042 import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor;
043 import org.jetbrains.kotlin.util.Box;
044 import org.jetbrains.kotlin.util.slicedMap.*;
045
046 import java.util.Collection;
047 import java.util.Collections;
048
049 import static org.jetbrains.kotlin.util.slicedMap.RewritePolicy.DO_NOTHING;
050
051 public interface BindingContext {
052 BindingContext EMPTY = new BindingContext() {
053 @NotNull
054 @Override
055 public Diagnostics getDiagnostics() {
056 return Diagnostics.Companion.getEMPTY();
057 }
058
059 @Override
060 public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
061 return null;
062 }
063
064 @NotNull
065 @Override
066 public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
067 return Collections.emptyList();
068 }
069
070 @NotNull
071 @TestOnly
072 @Override
073 public <K, V> ImmutableMap<K, V> getSliceContents(@NotNull ReadOnlySlice<K, V> slice) {
074 return ImmutableMap.of();
075 }
076
077 @Nullable
078 @Override
079 public KotlinType getType(@NotNull KtExpression expression) {
080 return null;
081 }
082
083 @Override
084 public void addOwnDataTo(@NotNull BindingTrace trace, boolean commitDiagnostics) {
085 // Do nothing
086 }
087 };
088
089 WritableSlice<KtAnnotationEntry, AnnotationDescriptor> ANNOTATION = Slices.createSimpleSlice();
090
091 WritableSlice<KtExpression, CompileTimeConstant<?>> COMPILE_TIME_VALUE = Slices.createSimpleSlice();
092
093 WritableSlice<KtTypeReference, KotlinType> TYPE = Slices.createSimpleSlice();
094 WritableSlice<KtExpression, KotlinTypeInfo> EXPRESSION_TYPE_INFO = new BasicWritableSlice<KtExpression, KotlinTypeInfo>(DO_NOTHING);
095 WritableSlice<KtExpression, KotlinType> EXPECTED_EXPRESSION_TYPE = new BasicWritableSlice<KtExpression, KotlinType>(DO_NOTHING);
096 WritableSlice<KtFunction, KotlinType> EXPECTED_RETURN_TYPE = new BasicWritableSlice<KtFunction, KotlinType>(DO_NOTHING);
097 WritableSlice<KtExpression, DataFlowInfo> DATAFLOW_INFO_AFTER_CONDITION = Slices.createSimpleSlice();
098
099 /**
100 * A qualifier corresponds to a receiver expression (if any). For 'A.B' qualifier is recorded for 'A'.
101 */
102 WritableSlice<KtExpression, Qualifier> QUALIFIER = new BasicWritableSlice<KtExpression, Qualifier>(DO_NOTHING);
103
104 WritableSlice<KtReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET =
105 new BasicWritableSlice<KtReferenceExpression, DeclarationDescriptor>(DO_NOTHING);
106 // if 'A' really means 'A.Companion' then this slice stores class descriptor for A, REFERENCE_TARGET stores descriptor Companion in this case
107 WritableSlice<KtReferenceExpression, ClassDescriptor> SHORT_REFERENCE_TO_COMPANION_OBJECT =
108 new BasicWritableSlice<KtReferenceExpression, ClassDescriptor>(DO_NOTHING);
109
110 WritableSlice<Call, ResolvedCall<?>> RESOLVED_CALL = new BasicWritableSlice<Call, ResolvedCall<?>>(DO_NOTHING);
111 WritableSlice<ResolvedCall<?>, TailRecursionKind> TAIL_RECURSION_CALL = Slices.createSimpleSlice();
112 WritableSlice<KtElement, ConstraintSystemCompleter> CONSTRAINT_SYSTEM_COMPLETER = new BasicWritableSlice<KtElement, ConstraintSystemCompleter>(DO_NOTHING);
113 WritableSlice<KtElement, Call> CALL = new BasicWritableSlice<KtElement, Call>(DO_NOTHING);
114
115 WritableSlice<KtExpression, Collection<? extends DeclarationDescriptor>> AMBIGUOUS_REFERENCE_TARGET =
116 new BasicWritableSlice<KtExpression, Collection<? extends DeclarationDescriptor>>(DO_NOTHING);
117
118 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_ITERATOR_RESOLVED_CALL = Slices.createSimpleSlice();
119
120 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_HAS_NEXT_RESOLVED_CALL = Slices.createSimpleSlice();
121 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_NEXT_RESOLVED_CALL = Slices.createSimpleSlice();
122
123 WritableSlice<PropertyAccessorDescriptor, ResolvedCall<FunctionDescriptor>> DELEGATED_PROPERTY_RESOLVED_CALL = Slices.createSimpleSlice();
124 WritableSlice<PropertyAccessorDescriptor, Call> DELEGATED_PROPERTY_CALL = Slices.createSimpleSlice();
125
126 WritableSlice<PropertyDescriptor, ResolvedCall<FunctionDescriptor>> DELEGATED_PROPERTY_PD_RESOLVED_CALL = Slices.createSimpleSlice();
127
128 WritableSlice<KtMultiDeclarationEntry, ResolvedCall<FunctionDescriptor>> COMPONENT_RESOLVED_CALL = Slices.createSimpleSlice();
129
130 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> INDEXED_LVALUE_GET = Slices.createSimpleSlice();
131 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> INDEXED_LVALUE_SET = Slices.createSimpleSlice();
132
133 WritableSlice<KtExpression, KotlinType> SMARTCAST = Slices.createSimpleSlice();
134
135 WritableSlice<KtWhenExpression, Boolean> EXHAUSTIVE_WHEN = Slices.createSimpleSlice();
136
137 WritableSlice<KtElement, LexicalScope> LEXICAL_SCOPE = Slices.createSimpleSlice();
138
139 WritableSlice<ScriptDescriptor, LexicalScope> SCRIPT_SCOPE = Slices.createSimpleSlice();
140
141 WritableSlice<KtExpression, Boolean> VARIABLE_REASSIGNMENT = Slices.createSimpleSetSlice();
142 WritableSlice<ValueParameterDescriptor, Boolean> AUTO_CREATED_IT = Slices.createSimpleSetSlice();
143
144 /**
145 * Has type of current expression has been already resolved
146 */
147 WritableSlice<KtExpression, Boolean> PROCESSED = Slices.createSimpleSetSlice();
148 WritableSlice<KtElement, Boolean> USED_AS_EXPRESSION = Slices.createSimpleSetSlice();
149 WritableSlice<KtElement, Boolean> UNREACHABLE_CODE = Slices.createSimpleSetSlice();
150
151 WritableSlice<VariableDescriptor, CaptureKind> CAPTURED_IN_CLOSURE = new BasicWritableSlice<VariableDescriptor, CaptureKind>(DO_NOTHING);
152 WritableSlice<KtDeclaration, PreliminaryDeclarationVisitor> PRELIMINARY_VISITOR = new BasicWritableSlice<KtDeclaration, PreliminaryDeclarationVisitor>(DO_NOTHING);
153
154 WritableSlice<CallableMemberDescriptor, Boolean> NEED_SYNTHETIC_ACCESSOR = new BasicWritableSlice<CallableMemberDescriptor, Boolean>(DO_NOTHING);
155
156 WritableSlice<Box<DeferredType>, Boolean> DEFERRED_TYPE = Slices.createCollectiveSetSlice();
157
158 WritableSlice<PropertyDescriptor, Boolean> BACKING_FIELD_REQUIRED = new Slices.SetSlice<PropertyDescriptor>(DO_NOTHING) {
159 @Override
160 public Boolean computeValue(
161 SlicedMap map,
162 PropertyDescriptor propertyDescriptor,
163 Boolean backingFieldRequired,
164 boolean valueNotFound
165 ) {
166 if (propertyDescriptor.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
167 return false;
168 }
169 backingFieldRequired = valueNotFound ? false : backingFieldRequired;
170 PsiElement declarationPsiElement = DescriptorToSourceUtils.descriptorToDeclaration(propertyDescriptor);
171 if (declarationPsiElement instanceof KtParameter) {
172 KtParameter jetParameter = (KtParameter) declarationPsiElement;
173 return jetParameter.hasValOrVar() ||
174 backingFieldRequired; // this part is unused because we do not allow access to constructor parameters in member bodies
175 }
176 if (propertyDescriptor.getModality() == Modality.ABSTRACT) return false;
177 PropertyGetterDescriptor getter = propertyDescriptor.getGetter();
178 PropertySetterDescriptor setter = propertyDescriptor.getSetter();
179
180 if (getter == null) return true;
181 if (propertyDescriptor.isVar() && setter == null) return true;
182 if (setter != null && !setter.hasBody() && setter.getModality() != Modality.ABSTRACT) return true;
183 if (!getter.hasBody() && getter.getModality() != Modality.ABSTRACT) return true;
184
185 return backingFieldRequired;
186 }
187 };
188 WritableSlice<PropertyDescriptor, Boolean> IS_UNINITIALIZED = Slices.createSimpleSetSlice();
189
190 WritableSlice<KtFunctionLiteralExpression, Boolean> BLOCK = new Slices.SetSlice<KtFunctionLiteralExpression>(DO_NOTHING) {
191 @Override
192 public Boolean computeValue(SlicedMap map, KtFunctionLiteralExpression expression, Boolean isBlock, boolean valueNotFound) {
193 isBlock = valueNotFound ? false : isBlock;
194 return isBlock && !expression.getFunctionLiteral().hasParameterSpecification();
195 }
196 };
197
198 WritableSlice<PsiElement, ClassDescriptor> CLASS = Slices.createSimpleSlice();
199 WritableSlice<PsiElement, ScriptDescriptor> SCRIPT = Slices.createSimpleSlice();
200 WritableSlice<KtTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = Slices.createSimpleSlice();
201 /**
202 * @see BindingContextUtils#recordFunctionDeclarationToDescriptor(BindingTrace, PsiElement, SimpleFunctionDescriptor)}
203 */
204 WritableSlice<PsiElement, SimpleFunctionDescriptor> FUNCTION = Slices.createSimpleSlice();
205 WritableSlice<PsiElement, ConstructorDescriptor> CONSTRUCTOR = Slices.createSimpleSlice();
206 WritableSlice<ConstructorDescriptor, ResolvedCall<ConstructorDescriptor>> CONSTRUCTOR_RESOLVED_DELEGATION_CALL =
207 Slices.createSimpleSlice();
208 WritableSlice<PsiElement, VariableDescriptor> VARIABLE = Slices.createSimpleSlice();
209 WritableSlice<KtParameter, VariableDescriptor> VALUE_PARAMETER = Slices.createSimpleSlice();
210 WritableSlice<KtPropertyAccessor, PropertyAccessorDescriptor> PROPERTY_ACCESSOR = Slices.createSimpleSlice();
211 WritableSlice<PsiElement, PropertyDescriptor> PRIMARY_CONSTRUCTOR_PARAMETER = Slices.createSimpleSlice();
212
213 WritableSlice[] DECLARATIONS_TO_DESCRIPTORS = new WritableSlice[] {
214 CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PROPERTY_ACCESSOR,
215 PRIMARY_CONSTRUCTOR_PARAMETER
216 };
217
218 @SuppressWarnings("unchecked")
219 ReadOnlySlice<PsiElement, DeclarationDescriptor> DECLARATION_TO_DESCRIPTOR =
220 Slices.<PsiElement, DeclarationDescriptor>sliceBuilder()
221 .setFurtherLookupSlices(DECLARATIONS_TO_DESCRIPTORS)
222 .build();
223
224 WritableSlice<KtReferenceExpression, PsiElement> LABEL_TARGET = Slices.createSimpleSlice();
225 WritableSlice<KtReferenceExpression, Collection<? extends PsiElement>> AMBIGUOUS_LABEL_TARGET = Slices.createSimpleSlice();
226 WritableSlice<ValueParameterDescriptor, PropertyDescriptor> VALUE_PARAMETER_AS_PROPERTY = Slices.createSimpleSlice();
227
228 WritableSlice<ValueParameterDescriptor, FunctionDescriptor> DATA_CLASS_COMPONENT_FUNCTION = Slices.createSimpleSlice();
229 WritableSlice<ClassDescriptor, FunctionDescriptor> DATA_CLASS_COPY_FUNCTION = Slices.createSimpleSlice();
230
231 WritableSlice<FqNameUnsafe, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR =
232 new BasicWritableSlice<FqNameUnsafe, ClassDescriptor>(DO_NOTHING, true);
233 WritableSlice<KtFile, PackageFragmentDescriptor> FILE_TO_PACKAGE_FRAGMENT = Slices.createSimpleSlice();
234 WritableSlice<FqName, Collection<KtFile>> PACKAGE_TO_FILES = Slices.createSimpleSlice();
235
236 @SuppressWarnings("UnusedDeclaration")
237 @Deprecated // This field is needed only for the side effects of its initializer
238 Void _static_initializer = BasicWritableSlice.initSliceDebugNames(BindingContext.class);
239
240 @NotNull
241 Diagnostics getDiagnostics();
242
243 @Nullable
244 <K, V> V get(ReadOnlySlice<K, V> slice, K key);
245
246 // slice.isCollective() must be true
247 @NotNull
248 @ReadOnly
249 <K, V> Collection<K> getKeys(WritableSlice<K, V> slice);
250
251 /** This method should be used only for debug and testing */
252 @TestOnly
253 @NotNull
254 <K, V> ImmutableMap<K, V> getSliceContents(@NotNull ReadOnlySlice<K, V> slice);
255
256 @Nullable
257 KotlinType getType(@NotNull KtExpression expression);
258
259 void addOwnDataTo(@NotNull BindingTrace trace, boolean commitDiagnostics);
260 }