001 /*
002 * Copyright 2010-2016 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.LeakingThisDescriptor;
026 import org.jetbrains.kotlin.cfg.TailRecursionKind;
027 import org.jetbrains.kotlin.descriptors.*;
028 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
029 import org.jetbrains.kotlin.name.FqName;
030 import org.jetbrains.kotlin.name.FqNameUnsafe;
031 import org.jetbrains.kotlin.psi.*;
032 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemCompleter;
033 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
034 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
035 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue;
036 import org.jetbrains.kotlin.resolve.calls.smartcasts.ExplicitSmartCasts;
037 import org.jetbrains.kotlin.resolve.calls.smartcasts.ImplicitSmartCasts;
038 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
039 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
040 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
041 import org.jetbrains.kotlin.resolve.scopes.receivers.Qualifier;
042 import org.jetbrains.kotlin.types.DeferredType;
043 import org.jetbrains.kotlin.types.KotlinType;
044 import org.jetbrains.kotlin.types.expressions.CaptureKind;
045 import org.jetbrains.kotlin.types.expressions.DoubleColonLHS;
046 import org.jetbrains.kotlin.types.expressions.KotlinTypeInfo;
047 import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor;
048 import org.jetbrains.kotlin.util.Box;
049 import org.jetbrains.kotlin.util.slicedMap.*;
050
051 import java.util.Collection;
052 import java.util.Collections;
053
054 import static org.jetbrains.kotlin.util.slicedMap.RewritePolicy.DO_NOTHING;
055
056 public interface BindingContext {
057 BindingContext EMPTY = new BindingContext() {
058 @NotNull
059 @Override
060 public Diagnostics getDiagnostics() {
061 return Diagnostics.Companion.getEMPTY();
062 }
063
064 @Override
065 public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
066 return null;
067 }
068
069 @NotNull
070 @Override
071 public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
072 return Collections.emptyList();
073 }
074
075 @NotNull
076 @TestOnly
077 @Override
078 public <K, V> ImmutableMap<K, V> getSliceContents(@NotNull ReadOnlySlice<K, V> slice) {
079 return ImmutableMap.of();
080 }
081
082 @Nullable
083 @Override
084 public KotlinType getType(@NotNull KtExpression expression) {
085 return null;
086 }
087
088 @Override
089 public void addOwnDataTo(@NotNull BindingTrace trace, boolean commitDiagnostics) {
090 // Do nothing
091 }
092 };
093
094 WritableSlice<KtAnnotationEntry, AnnotationDescriptor> ANNOTATION = Slices.createSimpleSlice();
095
096 WritableSlice<KtExpression, CompileTimeConstant<?>> COMPILE_TIME_VALUE = Slices.createSimpleSlice();
097
098 WritableSlice<KtTypeReference, KotlinType> TYPE = Slices.createSimpleSlice();
099 WritableSlice<KtTypeReference, KotlinType> ABBREVIATED_TYPE = Slices.createSimpleSlice();
100 WritableSlice<KtExpression, KotlinTypeInfo> EXPRESSION_TYPE_INFO = new BasicWritableSlice<KtExpression, KotlinTypeInfo>(DO_NOTHING);
101 WritableSlice<KtExpression, DataFlowInfo> DATA_FLOW_INFO_BEFORE = new BasicWritableSlice<KtExpression, DataFlowInfo>(DO_NOTHING);
102 WritableSlice<KtExpression, KotlinType> EXPECTED_EXPRESSION_TYPE = new BasicWritableSlice<KtExpression, KotlinType>(DO_NOTHING);
103 WritableSlice<KtFunction, KotlinType> EXPECTED_RETURN_TYPE = new BasicWritableSlice<KtFunction, KotlinType>(DO_NOTHING);
104 WritableSlice<KtExpression, DataFlowInfo> DATAFLOW_INFO_AFTER_CONDITION = Slices.createSimpleSlice();
105 WritableSlice<VariableDescriptor, DataFlowValue> BOUND_INITIALIZER_VALUE = Slices.createSimpleSlice();
106 WritableSlice<KtExpression, LeakingThisDescriptor> LEAKING_THIS = Slices.createSimpleSlice();
107
108 /**
109 * A qualifier corresponds to a receiver expression (if any). For 'A.B' qualifier is recorded for 'A'.
110 */
111 WritableSlice<KtExpression, Qualifier> QUALIFIER = new BasicWritableSlice<KtExpression, Qualifier>(DO_NOTHING);
112
113 WritableSlice<KtExpression, DoubleColonLHS> DOUBLE_COLON_LHS = new BasicWritableSlice<KtExpression, DoubleColonLHS>(DO_NOTHING);
114
115 WritableSlice<KtSuperExpression, KotlinType> THIS_TYPE_FOR_SUPER_EXPRESSION =
116 new BasicWritableSlice<KtSuperExpression, KotlinType>(DO_NOTHING);
117
118 WritableSlice<KtReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET =
119 new BasicWritableSlice<KtReferenceExpression, DeclarationDescriptor>(DO_NOTHING);
120 // if 'A' really means 'A.Companion' then this slice stores class descriptor for A, REFERENCE_TARGET stores descriptor Companion in this case
121 WritableSlice<KtReferenceExpression, ClassifierDescriptorWithTypeParameters> SHORT_REFERENCE_TO_COMPANION_OBJECT =
122 new BasicWritableSlice<KtReferenceExpression, ClassifierDescriptorWithTypeParameters>(DO_NOTHING);
123
124 WritableSlice<Call, ResolvedCall<?>> RESOLVED_CALL = new BasicWritableSlice<Call, ResolvedCall<?>>(DO_NOTHING);
125 WritableSlice<Call, TailRecursionKind> TAIL_RECURSION_CALL = Slices.createSimpleSlice();
126 WritableSlice<KtElement, ConstraintSystemCompleter> CONSTRAINT_SYSTEM_COMPLETER = new BasicWritableSlice<KtElement, ConstraintSystemCompleter>(DO_NOTHING);
127 WritableSlice<KtElement, Call> CALL = new BasicWritableSlice<KtElement, Call>(DO_NOTHING);
128
129 WritableSlice<KtExpression, Collection<? extends DeclarationDescriptor>> AMBIGUOUS_REFERENCE_TARGET =
130 new BasicWritableSlice<KtExpression, Collection<? extends DeclarationDescriptor>>(DO_NOTHING);
131
132 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_ITERATOR_RESOLVED_CALL = Slices.createSimpleSlice();
133
134 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_HAS_NEXT_RESOLVED_CALL = Slices.createSimpleSlice();
135 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> LOOP_RANGE_NEXT_RESOLVED_CALL = Slices.createSimpleSlice();
136 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> RETURN_HANDLE_RESULT_RESOLVED_CALL = Slices.createSimpleSlice();
137
138 WritableSlice<Call, FunctionDescriptor> ENCLOSING_SUSPEND_FUNCTION_FOR_SUSPEND_FUNCTION_CALL = Slices.createSimpleSlice();
139 WritableSlice<FunctionDescriptor, Boolean> CONTAINS_NON_TAIL_SUSPEND_CALLS = Slices.createSimpleSetSlice();
140 WritableSlice<KtExpression, Boolean> IS_TAIL_EXPRESSION_IN_SUSPEND_FUNCTION = Slices.createSimpleSetSlice();
141
142 WritableSlice<VariableAccessorDescriptor, ResolvedCall<FunctionDescriptor>> DELEGATED_PROPERTY_RESOLVED_CALL = Slices.createSimpleSlice();
143 WritableSlice<VariableAccessorDescriptor, Call> DELEGATED_PROPERTY_CALL = Slices.createSimpleSlice();
144 WritableSlice<VariableDescriptorWithAccessors, ResolvedCall<FunctionDescriptor>> PROVIDE_DELEGATE_RESOLVED_CALL = Slices.createSimpleSlice();
145 WritableSlice<VariableDescriptorWithAccessors, Call> PROVIDE_DELEGATE_CALL = Slices.createSimpleSlice();
146
147 WritableSlice<KtDestructuringDeclarationEntry, ResolvedCall<FunctionDescriptor>> COMPONENT_RESOLVED_CALL = Slices.createSimpleSlice();
148
149 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> INDEXED_LVALUE_GET = Slices.createSimpleSlice();
150 WritableSlice<KtExpression, ResolvedCall<FunctionDescriptor>> INDEXED_LVALUE_SET = Slices.createSimpleSlice();
151
152 WritableSlice<KtExpression, ExplicitSmartCasts> SMARTCAST = new BasicWritableSlice<KtExpression, ExplicitSmartCasts>(DO_NOTHING);
153 WritableSlice<KtExpression, Boolean> SMARTCAST_NULL = Slices.createSimpleSlice();
154 WritableSlice<KtExpression, ImplicitSmartCasts> IMPLICIT_RECEIVER_SMARTCAST = new BasicWritableSlice<KtExpression, ImplicitSmartCasts>(DO_NOTHING);
155
156 WritableSlice<KtWhenExpression, Boolean> EXHAUSTIVE_WHEN = Slices.createSimpleSlice();
157 WritableSlice<KtWhenExpression, Boolean> IMPLICIT_EXHAUSTIVE_WHEN = Slices.createSimpleSlice();
158
159 WritableSlice<KtElement, LexicalScope> LEXICAL_SCOPE = Slices.createSimpleSlice();
160
161 WritableSlice<ScriptDescriptor, LexicalScope> SCRIPT_SCOPE = Slices.createSimpleSlice();
162
163 WritableSlice<KtExpression, Boolean> VARIABLE_REASSIGNMENT = Slices.createSimpleSetSlice();
164 WritableSlice<ValueParameterDescriptor, Boolean> AUTO_CREATED_IT = Slices.createSimpleSetSlice();
165
166 /**
167 * Has type of current expression has been already resolved
168 */
169 WritableSlice<KtExpression, Boolean> PROCESSED = Slices.createSimpleSlice();
170 WritableSlice<KtElement, Boolean> USED_AS_EXPRESSION = Slices.createSimpleSetSlice();
171 WritableSlice<KtElement, Boolean> USED_AS_RESULT_OF_LAMBDA = Slices.createSimpleSetSlice();
172 WritableSlice<KtElement, Boolean> UNREACHABLE_CODE = Slices.createSimpleSetSlice();
173
174 WritableSlice<VariableDescriptor, CaptureKind> CAPTURED_IN_CLOSURE = new BasicWritableSlice<VariableDescriptor, CaptureKind>(DO_NOTHING);
175 WritableSlice<KtDeclaration, PreliminaryDeclarationVisitor> PRELIMINARY_VISITOR = new BasicWritableSlice<KtDeclaration, PreliminaryDeclarationVisitor>(DO_NOTHING);
176
177 WritableSlice<Box<DeferredType>, Boolean> DEFERRED_TYPE = Slices.createCollectiveSetSlice();
178
179 WritableSlice<PropertyDescriptor, Boolean> BACKING_FIELD_REQUIRED = new SetSlice<PropertyDescriptor>(DO_NOTHING) {
180 @Override
181 public Boolean computeValue(
182 SlicedMap map,
183 PropertyDescriptor propertyDescriptor,
184 Boolean backingFieldRequired,
185 boolean valueNotFound
186 ) {
187 if (propertyDescriptor.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
188 return false;
189 }
190 backingFieldRequired = valueNotFound ? false : backingFieldRequired;
191 PsiElement declarationPsiElement = DescriptorToSourceUtils.descriptorToDeclaration(propertyDescriptor);
192 if (declarationPsiElement instanceof KtParameter) {
193 KtParameter jetParameter = (KtParameter) declarationPsiElement;
194 return jetParameter.hasValOrVar() ||
195 backingFieldRequired; // this part is unused because we do not allow access to constructor parameters in member bodies
196 }
197 if (propertyDescriptor.getModality() == Modality.ABSTRACT) return false;
198 if (declarationPsiElement instanceof KtProperty &&
199 ((KtProperty) declarationPsiElement).hasDelegate()) return false;
200 PropertyGetterDescriptor getter = propertyDescriptor.getGetter();
201 PropertySetterDescriptor setter = propertyDescriptor.getSetter();
202
203 if (getter == null) return true;
204 if (propertyDescriptor.isVar() && setter == null) return true;
205 if (setter != null && !DescriptorPsiUtilsKt.hasBody(setter) && setter.getModality() != Modality.ABSTRACT) return true;
206 if (!DescriptorPsiUtilsKt.hasBody(getter) && getter.getModality() != Modality.ABSTRACT) return true;
207
208 return backingFieldRequired;
209 }
210 };
211 WritableSlice<PropertyDescriptor, Boolean> IS_UNINITIALIZED = Slices.createSimpleSetSlice();
212 WritableSlice<PropertyDescriptor, Boolean> MUST_BE_LATEINIT = Slices.createSimpleSetSlice();
213
214 WritableSlice<KtLambdaExpression, Boolean> BLOCK = new SetSlice<KtLambdaExpression>(DO_NOTHING) {
215 @Override
216 public Boolean computeValue(SlicedMap map, KtLambdaExpression expression, Boolean isBlock, boolean valueNotFound) {
217 isBlock = valueNotFound ? false : isBlock;
218 return isBlock && !expression.getFunctionLiteral().hasParameterSpecification();
219 }
220 };
221
222 WritableSlice<PsiElement, ClassDescriptor> CLASS = Slices.createSimpleSlice();
223 WritableSlice<PsiElement, ScriptDescriptor> SCRIPT = Slices.createSimpleSlice();
224 WritableSlice<KtTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = Slices.createSimpleSlice();
225 /**
226 * @see BindingContextUtils#recordFunctionDeclarationToDescriptor(BindingTrace, PsiElement, SimpleFunctionDescriptor)}
227 */
228 WritableSlice<PsiElement, SimpleFunctionDescriptor> FUNCTION = Slices.createSimpleSlice();
229 WritableSlice<PsiElement, ConstructorDescriptor> CONSTRUCTOR = Slices.createSimpleSlice();
230 WritableSlice<ConstructorDescriptor, ResolvedCall<ConstructorDescriptor>> CONSTRUCTOR_RESOLVED_DELEGATION_CALL =
231 Slices.createSimpleSlice();
232 WritableSlice<PsiElement, VariableDescriptor> VARIABLE = Slices.createSimpleSlice();
233 WritableSlice<KtParameter, VariableDescriptor> VALUE_PARAMETER = Slices.createSimpleSlice();
234 WritableSlice<KtPropertyAccessor, PropertyAccessorDescriptor> PROPERTY_ACCESSOR = Slices.createSimpleSlice();
235 WritableSlice<PsiElement, PropertyDescriptor> PRIMARY_CONSTRUCTOR_PARAMETER = Slices.createSimpleSlice();
236 WritableSlice<PsiElement, TypeAliasDescriptor> TYPE_ALIAS = Slices.createSimpleSlice();
237
238 WritableSlice[] DECLARATIONS_TO_DESCRIPTORS = new WritableSlice[] {
239 CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PROPERTY_ACCESSOR,
240 PRIMARY_CONSTRUCTOR_PARAMETER, SCRIPT, TYPE_ALIAS
241 };
242
243 @SuppressWarnings("unchecked")
244 ReadOnlySlice<PsiElement, DeclarationDescriptor> DECLARATION_TO_DESCRIPTOR =
245 Slices.<PsiElement, DeclarationDescriptor>sliceBuilder()
246 .setFurtherLookupSlices(DECLARATIONS_TO_DESCRIPTORS)
247 .build();
248
249 WritableSlice<KtReferenceExpression, PsiElement> LABEL_TARGET = Slices.createSimpleSlice();
250 WritableSlice<KtReferenceExpression, Collection<? extends PsiElement>> AMBIGUOUS_LABEL_TARGET = Slices.createSimpleSlice();
251 WritableSlice<ValueParameterDescriptor, PropertyDescriptor> VALUE_PARAMETER_AS_PROPERTY = Slices.createSimpleSlice();
252
253 WritableSlice<ValueParameterDescriptor, FunctionDescriptor> DATA_CLASS_COMPONENT_FUNCTION = Slices.createSimpleSlice();
254 WritableSlice<ClassDescriptor, FunctionDescriptor> DATA_CLASS_COPY_FUNCTION = Slices.createSimpleSlice();
255
256 WritableSlice<FqNameUnsafe, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR =
257 new BasicWritableSlice<FqNameUnsafe, ClassDescriptor>(DO_NOTHING, true);
258 WritableSlice<KtFile, PackageFragmentDescriptor> FILE_TO_PACKAGE_FRAGMENT = Slices.createSimpleSlice();
259 WritableSlice<FqName, Collection<KtFile>> PACKAGE_TO_FILES = Slices.createSimpleSlice();
260
261 @SuppressWarnings("UnusedDeclaration")
262 @Deprecated // This field is needed only for the side effects of its initializer
263 Void _static_initializer = BasicWritableSlice.initSliceDebugNames(BindingContext.class);
264
265 @NotNull
266 Diagnostics getDiagnostics();
267
268 @Nullable
269 <K, V> V get(ReadOnlySlice<K, V> slice, K key);
270
271 // slice.isCollective() must be true
272 @NotNull
273 @ReadOnly
274 <K, V> Collection<K> getKeys(WritableSlice<K, V> slice);
275
276 /** This method should be used only for debug and testing */
277 @TestOnly
278 @NotNull
279 <K, V> ImmutableMap<K, V> getSliceContents(@NotNull ReadOnlySlice<K, V> slice);
280
281 @Nullable
282 KotlinType getType(@NotNull KtExpression expression);
283
284 void addOwnDataTo(@NotNull BindingTrace trace, boolean commitDiagnostics);
285 }