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