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