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