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