From 1cfaf9ff74495415463654e213c3fca8c6df861b Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 26 May 2011 18:21:16 +0400 Subject: [PATCH 1/8] Assertion failure fixed --- .../resolve/java/JavaDescriptorResolver.java | 21 ++++-- .../checker/regression/DoubleDefine.jet | 66 +++++++++++++++++++ 2 files changed, 80 insertions(+), 7 deletions(-) create mode 100644 idea/testData/checker/regression/DoubleDefine.jet diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 53db17fe612..421fec69879 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -32,6 +32,7 @@ public class JavaDescriptorResolver { protected final Map classDescriptorCache = new HashMap(); protected final Map typeParameterDescriptorCache = Maps.newHashMap(); + protected final Map methodDescriptorCache = Maps.newHashMap(); protected final Map namespaceDescriptorCache = new HashMap(); protected final JavaPsiFacade javaFacade; protected final GlobalSearchScope javaSearchScope; @@ -247,28 +248,34 @@ public class JavaDescriptorResolver { WritableFunctionGroup writableFunctionGroup = new WritableFunctionGroup(methodName); final Collection signatures = psiClass.getVisibleSignatures(); for (HierarchicalMethodSignature signature: signatures) { - final PsiMethod method = signature.getMethod(); + PsiMethod method = signature.getMethod(); if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) { continue; } if (!methodName.equals(method.getName())) { continue; } - final PsiParameter[] parameters = method.getParameterList().getParameters(); + FunctionDescriptor functionDescriptor = methodDescriptorCache.get(method); + if (functionDescriptor != null) { + writableFunctionGroup.addFunction(functionDescriptor); + continue; + } - FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl( + PsiParameter[] parameters = method.getParameterList().getParameters(); + FunctionDescriptorImpl functionDescriptorImpl = new FunctionDescriptorImpl( JavaDescriptorResolver.JAVA_ROOT, Collections.emptyList(), // TODO methodName ); - functionDescriptor.initialize( + functionDescriptorImpl.initialize( null, resolveTypeParameters(method.getTypeParameters()), - semanticServices.getDescriptorResolver().resolveParameterDescriptors(functionDescriptor, parameters), + semanticServices.getDescriptorResolver().resolveParameterDescriptors(functionDescriptorImpl, parameters), semanticServices.getTypeTransformer().transformToType(method.getReturnType()) ); - semanticServices.getTrace().recordDeclarationResolution(method, functionDescriptor); - writableFunctionGroup.addFunction(functionDescriptor); + semanticServices.getTrace().recordDeclarationResolution(method, functionDescriptorImpl); + writableFunctionGroup.addFunction(functionDescriptorImpl); + methodDescriptorCache.put(method, functionDescriptorImpl); } return writableFunctionGroup; } diff --git a/idea/testData/checker/regression/DoubleDefine.jet b/idea/testData/checker/regression/DoubleDefine.jet new file mode 100644 index 00000000000..c622e1cdd10 --- /dev/null +++ b/idea/testData/checker/regression/DoubleDefine.jet @@ -0,0 +1,66 @@ +import java.* +import util.* + +import java.io.* + +fun takeFirst(expr: StringBuilder): Char { + val c = expr.charAt(0) + expr.deleteCharAt(0) + return c +} + +fun evaluateArg(expr: AbstractStringBuilder, numbers: ArrayList): Int { + if (expr.length() == 0) throw new Exception("Syntax error: Character expected"); + val c = takeFirst(expr) + if (c >= '0' && c <= '9') { + val n = c - '0' + if (!numbers.contains(n)) throw new Exception("You used incorrect number: " + n) + numbers.remove(n) + return n \ + } + throw new Exception("Syntax error: Unrecognized character " + c) +} + +fun evaluateAdd(expr: StringBuilder, numbers: ArrayList): Int { + val lhs = evaluateArg(expr, numbers) + if (expr.length() > 0) { + + } + return lhs +} + +fun evaluate(expr: StringBuilder, numbers: ArrayList): Int { + val lhs = evaluateAdd(expr, numbers) + if (expr.length() > 0) { + val c = expr.charAt(0) + expr.deleteCharAt(0) + } + return lhs +} + +fun main(args: Array) { + System.out?.println("24 game") + val numbers = new ArrayList(4) + val rnd = new Random(); + val prompt = new StringBuilder() + for(val i in 0..3) { + val n = rnd.nextInt(9) + 1 + numbers.add(n) + if (i > 0) prompt.append(" "); + prompt.append(n) + } + System.out?.println("Your numbers: " + prompt) + System.out?.println("Enter your expression:") + val reader = new BufferedReader(new InputStreamReader(System.`in`)) + val expr = new StringBuilder(reader.readLine()) + try { + val result = evaluate(expr, numbers) + if (result != 24) + System.out?.println("Sorry, that's " + result) + else + System.out?.println("You won!"); + } + catch(e: Throwable) { + System.out?.println(e.getMessage()) + } +} From 94788b77f427ada44b4801db75157ad9dab4dfc6 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 26 May 2011 19:10:08 +0400 Subject: [PATCH 2/8] JET-54 SOE on trying to call Collections.sort() --- .../descriptors/TypeParameterDescriptor.java | 9 ++- .../lang/resolve/AbstractScopeAdapter.java | 60 +++++++++++++++++++ .../jet/lang/resolve/JetScopeAdapter.java | 51 +--------------- .../jet/lang/resolve/LazyScopeAdapter.java | 22 +++++++ .../resolve/java/JavaDescriptorResolver.java | 3 +- 5 files changed, 94 insertions(+), 51 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java create mode 100644 idea/src/org/jetbrains/jet/lang/resolve/LazyScopeAdapter.java diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java b/idea/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java index 7e2d540afb1..73ce42da79c 100644 --- a/idea/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java @@ -2,6 +2,8 @@ package org.jetbrains.jet.lang.descriptors; import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.resolve.JetScope; +import org.jetbrains.jet.lang.resolve.LazyScopeAdapter; import org.jetbrains.jet.lang.types.*; import java.util.Collections; @@ -115,7 +117,12 @@ public class TypeParameterDescriptor extends DeclarationDescriptorImpl implement getTypeConstructor(), TypeUtils.hasNullableBound(this), Collections.emptyList(), - getBoundsAsType().getMemberScope()); + new LazyScopeAdapter(new LazyValue() { + @Override + protected JetScope compute() { + return getBoundsAsType().getMemberScope(); + } + })); } return type; } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java b/idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java new file mode 100644 index 00000000000..e12f17d9a6a --- /dev/null +++ b/idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java @@ -0,0 +1,60 @@ +package org.jetbrains.jet.lang.resolve; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.types.JetType; + +import java.util.Collection; + +/** + * @author abreslav + */ +public abstract class AbstractScopeAdapter implements JetScope { + @NotNull + protected abstract JetScope getWorkerScope(); + + @NotNull + @Override + public JetType getThisType() { + return getWorkerScope().getThisType(); + } + + @NotNull + @Override + public FunctionGroup getFunctionGroup(@NotNull String name) { + return getWorkerScope().getFunctionGroup(name); + } + + @Override + public NamespaceDescriptor getNamespace(@NotNull String name) { + return getWorkerScope().getNamespace(name); + } + + @Override + public ClassifierDescriptor getClassifier(@NotNull String name) { + return getWorkerScope().getClassifier(name); + } + + @Override + public VariableDescriptor getVariable(@NotNull String name) { + return getWorkerScope().getVariable(name); + } + + @NotNull + @Override + public DeclarationDescriptor getContainingDeclaration() { + return getWorkerScope().getContainingDeclaration(); + } + + @NotNull + @Override + public Collection getDeclarationsByLabel(String labelName) { + return getWorkerScope().getDeclarationsByLabel(labelName); + } + + @Override + public PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName) { + return getWorkerScope().getPropertyByFieldReference(fieldName); + } + +} diff --git a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java b/idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java index de7c5d0d2aa..a3b531bd831 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java @@ -1,15 +1,11 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.types.*; - -import java.util.Collection; /** * @author abreslav */ -public class JetScopeAdapter implements JetScope { +public class JetScopeAdapter extends AbstractScopeAdapter { @NotNull private final JetScope scope; @@ -18,51 +14,8 @@ public class JetScopeAdapter implements JetScope { } @NotNull + @Override protected final JetScope getWorkerScope() { return scope; } - - @NotNull - @Override - public JetType getThisType() { - return scope.getThisType(); - } - - @NotNull - @Override - public FunctionGroup getFunctionGroup(@NotNull String name) { - return scope.getFunctionGroup(name); - } - - @Override - public NamespaceDescriptor getNamespace(@NotNull String name) { - return scope.getNamespace(name); - } - - @Override - public ClassifierDescriptor getClassifier(@NotNull String name) { - return scope.getClassifier(name); - } - - @Override - public VariableDescriptor getVariable(@NotNull String name) { - return scope.getVariable(name); - } - - @NotNull - @Override - public DeclarationDescriptor getContainingDeclaration() { - return scope.getContainingDeclaration(); - } - - @NotNull - @Override - public Collection getDeclarationsByLabel(String labelName) { - return scope.getDeclarationsByLabel(labelName); - } - - @Override - public PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName) { - return scope.getPropertyByFieldReference(fieldName); - } } \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/lang/resolve/LazyScopeAdapter.java b/idea/src/org/jetbrains/jet/lang/resolve/LazyScopeAdapter.java new file mode 100644 index 00000000000..40a39ff5ca7 --- /dev/null +++ b/idea/src/org/jetbrains/jet/lang/resolve/LazyScopeAdapter.java @@ -0,0 +1,22 @@ +package org.jetbrains.jet.lang.resolve; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.types.LazyValue; + +/** + * @author abreslav + */ +public class LazyScopeAdapter extends AbstractScopeAdapter { + + private final LazyValue scope; + + public LazyScopeAdapter(LazyValue scope) { + this.scope = scope; + } + + @NotNull + @Override + protected JetScope getWorkerScope() { + return scope.get(); + } +} diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 421fec69879..43dcbea5c54 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -141,6 +141,7 @@ public class JavaDescriptorResolver { typeParameter.getName(), typeParameter.getIndex() ); + typeParameterDescriptorCache.put(typeParameter, typeParameterDescriptor); PsiClassType[] referencedTypes = typeParameter.getExtendsList().getReferencedTypes(); if (referencedTypes.length == 0){ typeParameterDescriptor.addUpperBound(JetStandardClasses.getNullableAnyType()); @@ -161,7 +162,7 @@ public class JavaDescriptorResolver { TypeParameterDescriptor typeParameterDescriptor = typeParameterDescriptorCache.get(psiTypeParameter); if (typeParameterDescriptor == null) { typeParameterDescriptor = createJavaTypeParameterDescriptor(JAVA_ROOT, psiTypeParameter); - typeParameterDescriptorCache.put(psiTypeParameter, typeParameterDescriptor); +// Tis is done inside the method: typeParameterDescriptorCache.put(psiTypeParameter, typeParameterDescriptor); } return typeParameterDescriptor; } From 009e983b4133ed6cd639f05b481b86a8f13393f5 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 26 May 2011 19:55:36 +0400 Subject: [PATCH 3/8] JET-58 Make 'as never succeeds' a warning, or even never check for Java (external) types --- .../jet/lang/types/JetTypeInferrer.java | 33 +++++++++++++------ idea/testData/checker/ResolveToJava.jet | 4 +++ .../jet/types/JetTypeCheckerTest.java | 2 ++ 3 files changed, 29 insertions(+), 10 deletions(-) diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index 8f601937604..79b696921f7 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -1,6 +1,7 @@ package org.jetbrains.jet.lang.types; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Maps; import com.google.common.collect.Sets; import com.intellij.lang.ASTNode; import com.intellij.psi.PsiElement; @@ -465,21 +466,32 @@ public class JetTypeInferrer { if (resolutionResult.isSuccess()) { final FunctionDescriptor functionDescriptor = resolutionResult.getFunctionDescriptor(); - List typeParameters = functionDescriptor.getOriginal().getTypeParameters(); - for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) { - TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i); - final JetType typeArgument = typeArguments.get(i); - if (!semanticServices.getTypeChecker().isSubtypeOf(typeArgument, typeParameterDescriptor.getBoundsAsType())) { - trace.getErrorHandler().genericError(jetTypeArguments.get(i).getNode(), "Bound of the type parameter " + DescriptorRenderer.TEXT.render(typeParameterDescriptor) + " is not respected by the type " + typeArgument); - } - - } + checkGenericBoundsInAFunctionCall(jetTypeArguments, typeArguments, functionDescriptor); return functionDescriptor.getUnsubstitutedReturnType(); } } return null; } + private void checkGenericBoundsInAFunctionCall(List jetTypeArguments, List typeArguments, FunctionDescriptor functionDescriptor) { + Map context = Maps.newHashMap(); + + List typeParameters = functionDescriptor.getOriginal().getTypeParameters(); + for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) { + TypeParameterDescriptor typeParameter = typeParameters.get(i); + JetType typeArgument = typeArguments.get(i); + context.put(typeParameter.getTypeConstructor(), new TypeProjection(typeArgument)); + } + TypeSubstitutor substitutor = TypeSubstitutor.create(context); + for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) { + TypeParameterDescriptor typeParameterDescriptor = typeParameters.get(i); + JetType typeArgument = typeArguments.get(i); + JetTypeReference typeReference = jetTypeArguments.get(i).getTypeReference(); + assert typeReference != null; + classDescriptorResolver.checkBounds(typeReference, typeArgument, typeParameterDescriptor, substitutor); + } + } + @Nullable public JetType checkConstructorCall(JetScope scope, @NotNull JetTypeReference typeReference, @NotNull JetCall call) { JetTypeElement typeElement = typeReference.getTypeElement(); @@ -891,7 +903,8 @@ public class JetTypeInferrer { trace.getErrorHandler().genericWarning(expression.getOperationSign().getNode(), "No cast needed, use ':' instead"); } else { - trace.getErrorHandler().genericError(expression.getOperationSign().getNode(), "This cast can never succeed"); + // See JET-58 Make 'as never succeeds' a warning, or even never check for Java (external) types + trace.getErrorHandler().genericWarning(expression.getOperationSign().getNode(), "This cast can never succeed"); } } else { diff --git a/idea/testData/checker/ResolveToJava.jet b/idea/testData/checker/ResolveToJava.jet index 5ae9aaba181..4641fca97bb 100644 --- a/idea/testData/checker/ResolveToJava.jet +++ b/idea/testData/checker/ResolveToJava.jet @@ -22,4 +22,8 @@ fun test(l : java.util.List) { Collections.singleton(1.0) new List + +// Collections.sort(new ArrayList()) + + val o = "sdf" as Object } diff --git a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 77e1747ab53..b26d8056b48 100644 --- a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -277,6 +277,8 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase { assertSubtype("Derived_T", "Base_T"); assertSubtype("MDerived_T", "Base_T"); assertSubtype("ArrayList", "List"); + + assertSubtype("Integer", "java.lang.Comparable?"); } public void testNullable() throws Exception { From cc26da07dfbe8f82586ea354fb6b216012a7e661 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 26 May 2011 20:00:43 +0400 Subject: [PATCH 4/8] A test for JET-55 Bogus overload ambiguity trying to call Exception.getMessage() --- idea/testData/checker/ResolveToJava.jet | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/idea/testData/checker/ResolveToJava.jet b/idea/testData/checker/ResolveToJava.jet index 4641fca97bb..428be3e3d62 100644 --- a/idea/testData/checker/ResolveToJava.jet +++ b/idea/testData/checker/ResolveToJava.jet @@ -26,4 +26,12 @@ fun test(l : java.util.List) { // Collections.sort(new ArrayList()) val o = "sdf" as Object + + try { + // ... + } + catch(e: Exception) { + System.out?.println(e.getMessage()) + } + } From d69f8459026a06f7fd9018a54eb33cf9d8d00680 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 26 May 2011 21:09:39 +0400 Subject: [PATCH 5/8] JET-53 Support import of individual classes from Java packages NOTE: imports for classes to be used as namespaces (eg, 'Collections.sort()') do not work yet --- .../jet/lang/resolve/TopDownAnalyzer.java | 37 ++++++++++++++++++- idea/testData/checker/ResolveToJava.jet | 8 ++++ 2 files changed, 43 insertions(+), 2 deletions(-) diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 4200d1378ff..703f05c0e76 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -12,7 +12,8 @@ import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.JetTypeInferrer; import org.jetbrains.jet.lexer.JetTokens; import java.util.*; @@ -133,7 +134,39 @@ public class TopDownAnalyzer { } } } else { - throw new UnsupportedOperationException(); + ClassifierDescriptor classifierDescriptor = null; + JetSimpleNameExpression referenceExpression = null; + + JetExpression importedReference = importDirective.getImportedReference(); + if (importedReference instanceof JetDotQualifiedExpression) { + JetDotQualifiedExpression reference = (JetDotQualifiedExpression) importedReference; + JetType type = semanticServices.getTypeInferrer(trace, JetFlowInformationProvider.THROW_EXCEPTION).getTypeWithNamespaces(namespaceScope, reference.getReceiverExpression(), false); + JetExpression selectorExpression = reference.getSelectorExpression(); + if (selectorExpression != null) { + referenceExpression = (JetSimpleNameExpression) selectorExpression; + String referencedName = referenceExpression.getReferencedName(); + if (type != null && referencedName != null) { + classifierDescriptor = type.getMemberScope().getClassifier(referencedName); + } + } + } + else { + assert importedReference instanceof JetSimpleNameExpression; + referenceExpression = (JetSimpleNameExpression) importedReference; + + String referencedName = referenceExpression.getReferencedName(); + if (referencedName != null) { + classifierDescriptor = outerScope.getClassifier(referencedName); + } + } + + if (classifierDescriptor != null) { + trace.recordReferenceResolution(referenceExpression, classifierDescriptor); + + String aliasName = importDirective.getAliasName(); + String importedClassifierName = aliasName != null ? aliasName : classifierDescriptor.getName(); + namespaceScope.addClassifierAlias(importedClassifierName, classifierDescriptor); + } } } diff --git a/idea/testData/checker/ResolveToJava.jet b/idea/testData/checker/ResolveToJava.jet index 428be3e3d62..99907a0d7cc 100644 --- a/idea/testData/checker/ResolveToJava.jet +++ b/idea/testData/checker/ResolveToJava.jet @@ -2,6 +2,9 @@ import java.* import util.* import utils.* +import java.io.PrintStream +import java.lang.Comparable as Com + val l : List = new ArrayList() fun test(l : java.util.List) { @@ -34,4 +37,9 @@ fun test(l : java.util.List) { System.out?.println(e.getMessage()) } + new PrintStream("sdf") + + val c : Com? = null + + c : java.lang.Comparable? } From b950a82fcdeeb56bc5c830dbe1e7d77686d79ba8 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 27 May 2011 13:54:46 +0400 Subject: [PATCH 6/8] Qualified this resolved correctly --- .../descriptors/MutableClassDescriptor.java | 7 +- .../jet/lang/resolve/ChainedScope.java | 95 +++++++++++++++++++ .../jet/lang/resolve/WritableScopeImpl.java | 2 +- .../resolve/WritableScopeWithImports.java | 13 +++ .../jet/lang/types/JetTypeInferrer.java | 1 + idea/testData/checker/ResolveToJava.jet | 9 +- idea/testData/resolve/Classifiers.jet | 14 ++- 7 files changed, 134 insertions(+), 7 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java b/idea/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java index f0283caa89c..16bd49db7c4 100644 --- a/idea/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java @@ -30,10 +30,9 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme public MutableClassDescriptor(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope outerScope) { super(containingDeclaration); - this.scopeForMemberLookup = new WritableScopeImpl(JetScope.EMPTY, this, trace.getErrorHandler()); - this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, trace.getErrorHandler()); - this.scopeForMemberResolution = new WritableScopeImpl(scopeForMemberLookup, this, trace.getErrorHandler()); - scopeForMemberResolution.importScope(scopeForSupertypeResolution); + this.scopeForMemberLookup = new WritableScopeImpl(JetScope.EMPTY, this, trace.getErrorHandler()).setDebugName("MemberLookup"); + this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, trace.getErrorHandler()).setDebugName("SupertypeResolution"); + this.scopeForMemberResolution = new WritableScopeImpl(new ChainedScope(this, scopeForMemberLookup, scopeForSupertypeResolution), this, trace.getErrorHandler()).setDebugName("MemberResolution"); } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java b/idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java new file mode 100644 index 00000000000..1aae583dc43 --- /dev/null +++ b/idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java @@ -0,0 +1,95 @@ +package org.jetbrains.jet.lang.resolve; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.types.JetType; + +import java.util.Collection; +import java.util.Collections; + +/** + * @author abreslav + */ +public class ChainedScope implements JetScope { + private final DeclarationDescriptor containingDeclaration; + private final JetScope[] scopeChain; + + public ChainedScope(DeclarationDescriptor containingDeclaration, JetScope... scopes) { + this.containingDeclaration = containingDeclaration; + scopeChain = scopes.clone(); + } + + @Override + public ClassifierDescriptor getClassifier(@NotNull String name) { + for (JetScope scope : scopeChain) { + ClassifierDescriptor classifier = scope.getClassifier(name); + if (classifier != null) return classifier; + } + return null; + } + + @Override + public NamespaceDescriptor getNamespace(@NotNull String name) { + for (JetScope jetScope : scopeChain) { + NamespaceDescriptor namespace = jetScope.getNamespace(name); + if (namespace != null) { + return namespace; + } + } + return null; + } + + @Override + public VariableDescriptor getVariable(@NotNull String name) { + for (JetScope jetScope : scopeChain) { + VariableDescriptor variable = jetScope.getVariable(name); + if (variable != null) { + return variable; + } + } + return null; + } + + @NotNull + @Override + public FunctionGroup getFunctionGroup(@NotNull String name) { + for (JetScope jetScope : scopeChain) { + FunctionGroup functionGroup = jetScope.getFunctionGroup(name); + if (!functionGroup.isEmpty()) return functionGroup; + } + return FunctionGroup.EMPTY; + } + + @NotNull + @Override + public JetType getThisType() { + throw new UnsupportedOperationException(); // TODO + } + + @NotNull + @Override + public DeclarationDescriptor getContainingDeclaration() { + return containingDeclaration; + } + + @NotNull + @Override + public Collection getDeclarationsByLabel(String labelName) { + for (JetScope jetScope : scopeChain) { + Collection declarationsByLabel = jetScope.getDeclarationsByLabel(labelName); + if (!declarationsByLabel.isEmpty()) return declarationsByLabel; // TODO : merge? + } + return Collections.emptyList(); + } + + @Override + public PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName) { + for (JetScope jetScope : scopeChain) { + PropertyDescriptor propertyByFieldReference = jetScope.getPropertyByFieldReference(fieldName); + if (propertyByFieldReference != null) { + return propertyByFieldReference; + } + } + return null; + } +} diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java b/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java index 151ad21c783..78479fafb1a 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java @@ -59,8 +59,8 @@ public class WritableScopeImpl extends WritableScopeWithImports { @NotNull @Override public Collection getDeclarationsByLabel(@NotNull String labelName) { - Map> labelsToDescriptors = getLabelsToDescriptors(); Collection superResult = super.getDeclarationsByLabel(labelName); + Map> labelsToDescriptors = getLabelsToDescriptors(); List declarationDescriptors = labelsToDescriptors.get(labelName); if (declarationDescriptors == null) { return superResult; diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java b/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java index 0a557bc4256..381ab81ecbd 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java @@ -15,6 +15,8 @@ import java.util.List; */ public abstract class WritableScopeWithImports extends JetScopeAdapter implements WritableScope { + private String debugName; + @Nullable private List imports; @@ -22,6 +24,12 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement super(scope); } + public WritableScopeWithImports setDebugName(@NotNull String debugName) { + assert this.debugName == null : this.debugName; + this.debugName = debugName; + return this; + } + @NotNull protected final List getImports() { if (imports == null) { @@ -80,4 +88,9 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement } return null; } + + @Override + public String toString() { + return debugName + " for " + getContainingDeclaration(); + } } diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index 79b696921f7..5c949ae5242 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -938,6 +938,7 @@ public class JetTypeInferrer { if (declarationDescriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor; thisType = classDescriptor.getDefaultType(); + trace.recordReferenceResolution(expression.getTargetLabel(), classDescriptor); } else { throw new UnsupportedOperationException(); // TODO diff --git a/idea/testData/checker/ResolveToJava.jet b/idea/testData/checker/ResolveToJava.jet index 99907a0d7cc..ca8cbd774dd 100644 --- a/idea/testData/checker/ResolveToJava.jet +++ b/idea/testData/checker/ResolveToJava.jet @@ -26,7 +26,6 @@ fun test(l : java.util.List) { new List -// Collections.sort(new ArrayList()) val o = "sdf" as Object @@ -42,4 +41,12 @@ fun test(l : java.util.List) { val c : Com? = null c : java.lang.Comparable? + +// Collections.sort(new ArrayList()) + //new xxx.error>Class/error>() +} + + +namespace xxx { + import java.lang.Class; } diff --git a/idea/testData/resolve/Classifiers.jet b/idea/testData/resolve/Classifiers.jet index 19a5025f1b3..d9dfa80d85e 100644 --- a/idea/testData/resolve/Classifiers.jet +++ b/idea/testData/resolve/Classifiers.jet @@ -1,3 +1,14 @@ +namespace qualified_this { + ~qtA~class A(val a:Int) { + + ~qtB~class B() { + val x = this`qtB`@B + val y = this`qtA`@A + } + } +} + + class A<~T~T, ~E~E> { val a : `T`T val x : A<`T`T, `E`E> @@ -8,4 +19,5 @@ class A<~T~T, ~E~E> { ~X.E~class E {} } -} \ No newline at end of file +} + From e4df21c15054fcd2c97d32abcad65b4f460ce17b Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 27 May 2011 14:30:49 +0400 Subject: [PATCH 7/8] Name imports fixed --- .../jet/lang/resolve/TopDownAnalyzer.java | 104 +++++++++--------- .../jet/lang/resolve/WritableScopeImpl.java | 5 +- .../resolve/WritableScopeWithImports.java | 17 ++- .../jet/lang/resolve/WriteThroughScope.java | 5 +- .../jet/lang/types/JetTypeInferrer.java | 6 +- idea/testData/checker/ResolveToJava.jet | 2 +- 6 files changed, 78 insertions(+), 61 deletions(-) diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 703f05c0e76..a1aad553b7c 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -99,7 +99,6 @@ public class TopDownAnalyzer { declaration.accept(new JetVisitor() { @Override public void visitNamespace(JetNamespace namespace) { - List importDirectives = namespace.getImportDirectives(); String name = namespace.getName(); if (name == null) { @@ -118,57 +117,10 @@ public class TopDownAnalyzer { } namespaceDescriptors.put(namespace, namespaceDescriptor); - WritableScope namespaceScope = new WriteThroughScope(outerScope, (WritableScope) namespaceDescriptor.getMemberScope()); + WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), trace.getErrorHandler()); namespaceScopes.put(namespace, namespaceScope); - for (JetImportDirective importDirective : importDirectives) { - if (importDirective.isAbsoluteInRootNamespace()) { - throw new UnsupportedOperationException(); - } - if (importDirective.isAllUnder()) { - JetExpression importedReference = importDirective.getImportedReference(); - if (importedReference != null) { - JetType type = semanticServices.getTypeInferrer(trace, JetFlowInformationProvider.THROW_EXCEPTION).getTypeWithNamespaces(namespaceScope, importedReference, false); - if (type != null) { - namespaceScope.importScope(type.getMemberScope()); - } - } - } else { - ClassifierDescriptor classifierDescriptor = null; - JetSimpleNameExpression referenceExpression = null; - - JetExpression importedReference = importDirective.getImportedReference(); - if (importedReference instanceof JetDotQualifiedExpression) { - JetDotQualifiedExpression reference = (JetDotQualifiedExpression) importedReference; - JetType type = semanticServices.getTypeInferrer(trace, JetFlowInformationProvider.THROW_EXCEPTION).getTypeWithNamespaces(namespaceScope, reference.getReceiverExpression(), false); - JetExpression selectorExpression = reference.getSelectorExpression(); - if (selectorExpression != null) { - referenceExpression = (JetSimpleNameExpression) selectorExpression; - String referencedName = referenceExpression.getReferencedName(); - if (type != null && referencedName != null) { - classifierDescriptor = type.getMemberScope().getClassifier(referencedName); - } - } - } - else { - assert importedReference instanceof JetSimpleNameExpression; - referenceExpression = (JetSimpleNameExpression) importedReference; - - String referencedName = referenceExpression.getReferencedName(); - if (referencedName != null) { - classifierDescriptor = outerScope.getClassifier(referencedName); - } - } - - if (classifierDescriptor != null) { - trace.recordReferenceResolution(referenceExpression, classifierDescriptor); - - String aliasName = importDirective.getAliasName(); - String importedClassifierName = aliasName != null ? aliasName : classifierDescriptor.getName(); - namespaceScope.addClassifierAlias(importedClassifierName, classifierDescriptor); - } - } - } + processImports(namespace, namespaceScope, outerScope); collectNamespacesAndClassifiers(namespaceScope, namespaceDescriptor, namespace.getDeclarations()); } @@ -200,6 +152,58 @@ public class TopDownAnalyzer { } } + private void processImports(@NotNull JetNamespace namespace, @NotNull WriteThroughScope namespaceScope, @NotNull JetScope outerScope) { + List importDirectives = namespace.getImportDirectives(); + for (JetImportDirective importDirective : importDirectives) { + if (importDirective.isAbsoluteInRootNamespace()) { + throw new UnsupportedOperationException(); + } + if (importDirective.isAllUnder()) { + JetExpression importedReference = importDirective.getImportedReference(); + if (importedReference != null) { + JetType type = semanticServices.getTypeInferrer(trace, JetFlowInformationProvider.THROW_EXCEPTION).getTypeWithNamespaces(namespaceScope, importedReference, false); + if (type != null) { + namespaceScope.importScope(type.getMemberScope()); + } + } + } else { + ClassifierDescriptor classifierDescriptor = null; + JetSimpleNameExpression referenceExpression = null; + + JetExpression importedReference = importDirective.getImportedReference(); + if (importedReference instanceof JetDotQualifiedExpression) { + JetDotQualifiedExpression reference = (JetDotQualifiedExpression) importedReference; + JetType type = semanticServices.getTypeInferrer(trace, JetFlowInformationProvider.THROW_EXCEPTION).getTypeWithNamespaces(namespaceScope, reference.getReceiverExpression(), false); + JetExpression selectorExpression = reference.getSelectorExpression(); + if (selectorExpression != null) { + referenceExpression = (JetSimpleNameExpression) selectorExpression; + String referencedName = referenceExpression.getReferencedName(); + if (type != null && referencedName != null) { + classifierDescriptor = type.getMemberScope().getClassifier(referencedName); + } + } + } + else { + assert importedReference instanceof JetSimpleNameExpression; + referenceExpression = (JetSimpleNameExpression) importedReference; + + String referencedName = referenceExpression.getReferencedName(); + if (referencedName != null) { + classifierDescriptor = outerScope.getClassifier(referencedName); + } + } + + if (classifierDescriptor != null) { + trace.recordReferenceResolution(referenceExpression, classifierDescriptor); + + String aliasName = importDirective.getAliasName(); + String importedClassifierName = aliasName != null ? aliasName : classifierDescriptor.getName(); + namespaceScope.importClassifierAlias(importedClassifierName, classifierDescriptor); + } + } + } + } + private void createTypeConstructors() { for (Map.Entry entry : classes.entrySet()) { JetClass jetClass = entry.getKey(); diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java b/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java index 78479fafb1a..a9295fcf212 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java @@ -13,8 +13,6 @@ import java.util.*; * @author abreslav */ public class WritableScopeImpl extends WritableScopeWithImports { - @NotNull - private final ErrorHandler errorHandler; @NotNull private final DeclarationDescriptor ownerDeclarationDescriptor; @@ -37,9 +35,8 @@ public class WritableScopeImpl extends WritableScopeWithImports { private JetType thisType; public WritableScopeImpl(@NotNull JetScope scope, @NotNull DeclarationDescriptor owner, @NotNull ErrorHandler errorHandler) { - super(scope); + super(scope, errorHandler); this.ownerDeclarationDescriptor = owner; - this.errorHandler = errorHandler; } @NotNull diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java b/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java index 381ab81ecbd..9316b0e3d85 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java @@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.ErrorHandler; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionGroup; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; @@ -19,9 +20,12 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement @Nullable private List imports; + private WritableScope currentIndividualImportScope; + protected final ErrorHandler errorHandler; - public WritableScopeWithImports(@NotNull JetScope scope) { + public WritableScopeWithImports(@NotNull JetScope scope, @NotNull ErrorHandler errorHandler) { super(scope); + this.errorHandler = errorHandler; } public WritableScopeWithImports setDebugName(@NotNull String debugName) { @@ -41,6 +45,7 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement @Override public void importScope(@NotNull JetScope imported) { getImports().add(0, imported); + currentIndividualImportScope = null; } @Override @@ -89,8 +94,18 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement return null; } + public void importClassifierAlias(@NotNull String importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor) { + if (currentIndividualImportScope == null) { + WritableScopeImpl writableScope = new WritableScopeImpl(JetScope.EMPTY, getContainingDeclaration(), ErrorHandler.DO_NOTHING); + importScope(writableScope); + currentIndividualImportScope = writableScope; + } + currentIndividualImportScope.addClassifierAlias(importedClassifierName, classifierDescriptor); + } + @Override public String toString() { return debugName + " for " + getContainingDeclaration(); } + } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WriteThroughScope.java b/idea/src/org/jetbrains/jet/lang/resolve/WriteThroughScope.java index 2e46c632b8a..091c0bb80fa 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/WriteThroughScope.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/WriteThroughScope.java @@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.ErrorHandler; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.types.*; @@ -13,8 +14,8 @@ import java.util.Collection; public class WriteThroughScope extends WritableScopeWithImports { private final WritableScope writableWorker; - public WriteThroughScope(@NotNull JetScope outerScope, @NotNull WritableScope scope) { - super(outerScope); + public WriteThroughScope(@NotNull JetScope outerScope, @NotNull WritableScope scope, @NotNull ErrorHandler errorHandler) { + super(outerScope, errorHandler); this.writableWorker = scope; } diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index 5c949ae5242..773b4e76270 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -1407,9 +1407,9 @@ public class JetTypeInferrer { else { result = selectorReturnType; } - if (selectorExpression != null && result != null) { - trace.recordExpressionType(selectorExpression, result); - } +// if (selectorExpression != null && result != null) { +// trace.recordExpressionType(selectorExpression, result); +// } } } diff --git a/idea/testData/checker/ResolveToJava.jet b/idea/testData/checker/ResolveToJava.jet index ca8cbd774dd..b8271d51043 100644 --- a/idea/testData/checker/ResolveToJava.jet +++ b/idea/testData/checker/ResolveToJava.jet @@ -43,7 +43,7 @@ fun test(l : java.util.List) { c : java.lang.Comparable? // Collections.sort(new ArrayList()) - //new xxx.error>Class/error>() + new xxx.Class() } From 6a03ec3878e4fa923189773e752cdb8e0e35b757 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 27 May 2011 16:16:52 +0400 Subject: [PATCH 8/8] Tests fixed + 'this' is resolved to the corresponding declaration --- .../jetbrains/jet/codegen/JetTypeMapper.java | 3 +- .../lang/parsing/JetExpressionParsing.java | 3 + .../jet/lang/psi/JetSimpleNameExpression.java | 2 +- .../jet/lang/psi/JetThisExpression.java | 5 ++ .../lang/resolve/AbstractScopeAdapter.java | 4 ++ .../jet/lang/resolve/ChainedScope.java | 15 +++++ .../lang/resolve/ClassDescriptorResolver.java | 1 - .../jet/lang/resolve/DescriptorUtils.java | 33 +++++++++++ .../jetbrains/jet/lang/resolve/JetScope.java | 3 + .../jet/lang/resolve/JetScopeImpl.java | 5 ++ .../jet/lang/resolve/SubstitutingScope.java | 7 +++ .../jet/lang/resolve/WritableScopeImpl.java | 8 +++ .../resolve/java/JavaClassMembersScope.java | 5 ++ .../jetbrains/jet/lang/types/ErrorUtils.java | 5 ++ .../jet/lang/types/JetTypeInferrer.java | 25 +++++--- idea/testData/psi/AnnotatedExpressions.txt | 3 +- idea/testData/psi/Labels.txt | 24 +++++--- idea/testData/psi/Properties.txt | 3 +- idea/testData/psi/SimpleExpressions.txt | 6 +- idea/testData/psi/examples/BinaryTree.txt | 15 +++-- idea/testData/psi/examples/BitArith.txt | 3 +- .../psi/examples/PolymorphicClassObjects.txt | 3 +- idea/testData/psi/examples/UnionFind.txt | 3 +- .../psi/examples/collections/ArrayList.txt | 3 +- .../psi/examples/collections/HashMap.txt | 9 ++- .../psi/examples/collections/List.txt | 6 +- .../examples/priorityqueues/BinaryHeap.txt | 57 ++++++++++++------- idea/testData/resolve/Classifiers.jet | 9 ++- .../tests/org/jetbrains/jet/JetTestUtils.java | 1 + 29 files changed, 211 insertions(+), 58 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java diff --git a/idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 71c516ba0c2..701a18f0740 100644 --- a/idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -3,6 +3,7 @@ package org.jetbrains.jet.codegen; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiElement; import jet.typeinfo.TypeInfo; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -125,7 +126,7 @@ public class JetTypeMapper { return mapType(jetType, OwnerKind.INTERFACE); } - public Type mapType(final JetType jetType, OwnerKind kind) { + public Type mapType(@NotNull final JetType jetType, OwnerKind kind) { if (jetType.equals(JetStandardClasses.getUnitType()) || jetType.equals(JetStandardClasses.getNothingType())) { return Type.VOID_TYPE; } diff --git a/idea/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java b/idea/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java index 9fa7a6a3919..c8d070b14fa 100644 --- a/idea/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java +++ b/idea/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java @@ -1520,7 +1520,10 @@ public class JetExpressionParsing extends AbstractJetParsing { private void parseThisExpression() { assert _at(THIS_KEYWORD); PsiBuilder.Marker mark = mark(); + + PsiBuilder.Marker thisReference = mark(); advance(); // THIS_KEYWORD + thisReference.done(REFERENCE_EXPRESSION); parseLabel(); diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java index 3943a329724..09a3b7643af 100644 --- a/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java +++ b/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java @@ -15,7 +15,7 @@ import org.jetbrains.jet.lexer.JetTokens; * @author max */ public class JetSimpleNameExpression extends JetReferenceExpression { - public static final TokenSet REFERENCE_TOKENS = TokenSet.orSet(JetTokens.LABELS, TokenSet.create(JetTokens.IDENTIFIER, JetTokens.FIELD_IDENTIFIER)); + public static final TokenSet REFERENCE_TOKENS = TokenSet.orSet(JetTokens.LABELS, TokenSet.create(JetTokens.IDENTIFIER, JetTokens.FIELD_IDENTIFIER, JetTokens.THIS_KEYWORD)); public JetSimpleNameExpression(@NotNull ASTNode node) { super(node); diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetThisExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetThisExpression.java index f7d3a7c6abe..87214721ecb 100644 --- a/idea/src/org/jetbrains/jet/lang/psi/JetThisExpression.java +++ b/idea/src/org/jetbrains/jet/lang/psi/JetThisExpression.java @@ -24,4 +24,9 @@ public class JetThisExpression extends JetLabelQualifiedExpression { return (JetTypeReference) findChildByType(JetNodeTypes.TYPE_REFERENCE); } + @NotNull + public JetReferenceExpression getThisReference() { + return (JetReferenceExpression) findChildByType(JetNodeTypes.REFERENCE_EXPRESSION); + } + } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java b/idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java index e12f17d9a6a..f71ad7d28c0 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java @@ -57,4 +57,8 @@ public abstract class AbstractScopeAdapter implements JetScope { return getWorkerScope().getPropertyByFieldReference(fieldName); } + @Override + public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { + return getWorkerScope().getDeclarationDescriptorForUnqualifiedThis(); + } } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java b/idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java index 1aae583dc43..9a154c70daa 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/ChainedScope.java @@ -92,4 +92,19 @@ public class ChainedScope implements JetScope { } return null; } + + @Override + public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { + if (DescriptorUtils.definesItsOwnThis(getContainingDeclaration())) { + return getContainingDeclaration(); + } + + for (JetScope jetScope : scopeChain) { + DeclarationDescriptor containingDeclaration = jetScope.getContainingDeclaration(); + if (DescriptorUtils.definesItsOwnThis(containingDeclaration)) { + return containingDeclaration; + } + } + return null; + } } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java index a66cfa3bbb2..c7b33c7b745 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java @@ -174,7 +174,6 @@ public class ClassDescriptorResolver { WritableScope innerScope = new WritableScopeImpl(scope, functionDescriptor, trace.getErrorHandler()); innerScope.addLabeledDeclaration(functionDescriptor); - List typeParameterDescriptors = resolveTypeParameters(functionDescriptor, innerScope, function.getTypeParameters()); JetType receiverType = null; diff --git a/idea/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/idea/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java new file mode 100644 index 00000000000..3fdd90e670e --- /dev/null +++ b/idea/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -0,0 +1,33 @@ +package org.jetbrains.jet.lang.resolve; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.*; + +/** + * @author abreslav + */ +public class DescriptorUtils { + public static boolean definesItsOwnThis(@NotNull DeclarationDescriptor descriptor) { + return descriptor.accept(new DeclarationDescriptorVisitor() { + @Override + public Boolean visitDeclarationDescriptor(DeclarationDescriptor descriptor, Void data) { + return false; + } + + @Override + public Boolean visitFunctionDescriptor(FunctionDescriptor descriptor, Void data) { + return descriptor.getReceiverType() != null; + } + + @Override + public Boolean visitClassDescriptor(ClassDescriptor descriptor, Void data) { + return true; + } + + @Override + public Boolean visitPropertyDescriptor(PropertyDescriptor descriptor, Void data) { + return descriptor.getReceiverType() != null; + } + }, null); + } +} diff --git a/idea/src/org/jetbrains/jet/lang/resolve/JetScope.java b/idea/src/org/jetbrains/jet/lang/resolve/JetScope.java index 2306644bb08..a13a4ea16cd 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/JetScope.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/JetScope.java @@ -46,4 +46,7 @@ public interface JetScope { */ @Nullable PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName); + + @Nullable + DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis(); } \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java b/idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java index c22c745e844..eee50eca2e5 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java @@ -48,4 +48,9 @@ public abstract class JetScopeImpl implements JetScope { public PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName) { return null; } + + @Override + public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { + return null; + } } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java b/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java index baf1625a26e..af1783429bd 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java @@ -1,6 +1,7 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.types.*; @@ -79,4 +80,10 @@ public class SubstitutingScope implements JetScope { public PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName) { throw new UnsupportedOperationException(); // TODO } + + @Override + @Nullable + public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { + return workerScope.getDeclarationDescriptorForUnqualifiedThis(); + } } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java b/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java index a9295fcf212..a6bf2db9b3c 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java @@ -45,6 +45,14 @@ public class WritableScopeImpl extends WritableScopeWithImports { return ownerDeclarationDescriptor; } + @Override + public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { + if (DescriptorUtils.definesItsOwnThis(ownerDeclarationDescriptor)) { + return ownerDeclarationDescriptor; + } + return super.getDeclarationDescriptorForUnqualifiedThis(); + } + @NotNull private Map> getLabelsToDescriptors() { if (labelsToDescriptors == null) { diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java index af73e5d911c..d8cbe10362f 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java @@ -47,6 +47,11 @@ public class JavaClassMembersScope implements JetScope { return null; } + @Override + public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { + throw new UnsupportedOperationException(); + } + @Override public ClassifierDescriptor getClassifier(@NotNull String name) { ClassifierDescriptor classifierDescriptor = classifiers.get(name); diff --git a/idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java b/idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java index c17a9950a81..b5c63b9c916 100644 --- a/idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java +++ b/idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java @@ -59,6 +59,11 @@ public class ErrorUtils { return null; // TODO : review } + @Override + public DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis() { + return ERROR_CLASS; // TODO : review + } + }; private static final FunctionGroup ERROR_FUNCTION_GROUP = new FunctionGroup() { diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index 773b4e76270..229a3a40818 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -933,28 +933,34 @@ public class JetTypeInferrer { if (labelName != null) { Collection declarationsByLabel = scope.getDeclarationsByLabel(labelName); int size = declarationsByLabel.size(); + final JetSimpleNameExpression targetLabel = expression.getTargetLabel(); + assert targetLabel != null; if (size == 1) { DeclarationDescriptor declarationDescriptor = declarationsByLabel.iterator().next(); if (declarationDescriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor; thisType = classDescriptor.getDefaultType(); - trace.recordReferenceResolution(expression.getTargetLabel(), classDescriptor); + trace.recordReferenceResolution(targetLabel, classDescriptor); + trace.recordReferenceResolution(expression.getThisReference(), classDescriptor); } else { throw new UnsupportedOperationException(); // TODO } } else if (size == 0) { - trace.getErrorHandler().unresolvedReference(expression.getTargetLabel()); + trace.getErrorHandler().unresolvedReference(targetLabel); } else { - JetSimpleNameExpression labelElement = expression.getTargetLabel(); - assert labelElement != null; - trace.getErrorHandler().genericError(labelElement.getNode(), "Ambiguous label"); + trace.getErrorHandler().genericError(targetLabel.getNode(), "Ambiguous label"); } } else { thisType = scope.getThisType(); + + DeclarationDescriptor declarationDescriptorForUnqualifiedThis = scope.getDeclarationDescriptorForUnqualifiedThis(); + if (declarationDescriptorForUnqualifiedThis != null) { + trace.recordReferenceResolution(expression.getThisReference(), declarationDescriptorForUnqualifiedThis); + } } if (thisType != null) { @@ -989,6 +995,9 @@ public class JetTypeInferrer { } else { result = thisType; } + if (result != null) { + trace.recordExpressionType(expression.getThisReference(), result); + } } } } @@ -1407,9 +1416,9 @@ public class JetTypeInferrer { else { result = selectorReturnType; } -// if (selectorExpression != null && result != null) { -// trace.recordExpressionType(selectorExpression, result); -// } + if (selectorExpression != null && result != null) { + trace.recordExpressionType(selectorExpression, result); + } } } diff --git a/idea/testData/psi/AnnotatedExpressions.txt b/idea/testData/psi/AnnotatedExpressions.txt index 3ab88e58209..43a7ec5594f 100644 --- a/idea/testData/psi/AnnotatedExpressions.txt +++ b/idea/testData/psi/AnnotatedExpressions.txt @@ -38,6 +38,7 @@ JetFile: AnnotatedExpressions.jet PsiElement(RBRACKET)(']') PsiWhiteSpace(' ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace('\n') PsiElement(RBRACE)('}') \ No newline at end of file diff --git a/idea/testData/psi/Labels.txt b/idea/testData/psi/Labels.txt index ab9aff54e8f..8f84afa425d 100644 --- a/idea/testData/psi/Labels.txt +++ b/idea/testData/psi/Labels.txt @@ -385,28 +385,33 @@ JetFile: Labels.jet PsiElement(RBRACE)('}') PsiWhiteSpace('\n\n ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace('\n ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') LABEL_QUALIFIER LABEL_REFERENCE PsiElement(AT)('@') PsiWhiteSpace('\n ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') LABEL_QUALIFIER LABEL_REFERENCE PsiElement(LABEL_IDENTIFIER)('@a') PsiWhiteSpace('\n ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') LABEL_QUALIFIER LABEL_REFERENCE PsiElement(ATAT)('@@') PsiWhiteSpace('\n\n ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(LT)('<') TYPE_REFERENCE USER_TYPE @@ -415,7 +420,8 @@ JetFile: Labels.jet PsiElement(GT)('>') PsiWhiteSpace('\n ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') LABEL_QUALIFIER LABEL_REFERENCE PsiElement(AT)('@') @@ -427,7 +433,8 @@ JetFile: Labels.jet PsiElement(GT)('>') PsiWhiteSpace('\n ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') LABEL_QUALIFIER LABEL_REFERENCE PsiElement(LABEL_IDENTIFIER)('@a') @@ -439,7 +446,8 @@ JetFile: Labels.jet PsiElement(GT)('>') PsiWhiteSpace('\n ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') LABEL_QUALIFIER LABEL_REFERENCE PsiElement(ATAT)('@@') diff --git a/idea/testData/psi/Properties.txt b/idea/testData/psi/Properties.txt index cada06eaa00..8011b4cd5db 100644 --- a/idea/testData/psi/Properties.txt +++ b/idea/testData/psi/Properties.txt @@ -768,7 +768,8 @@ JetFile: Properties.jet BINARY_EXPRESSION DOT_QUALIFIED_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('size') diff --git a/idea/testData/psi/SimpleExpressions.txt b/idea/testData/psi/SimpleExpressions.txt index 97f525a2ff6..6e5c056148c 100644 --- a/idea/testData/psi/SimpleExpressions.txt +++ b/idea/testData/psi/SimpleExpressions.txt @@ -261,7 +261,8 @@ JetFile: SimpleExpressions.jet PsiElement(EQ)('=') PsiWhiteSpace(' ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(COMMA)(',') PsiWhiteSpace('\n ') VALUE_PARAMETER @@ -277,7 +278,8 @@ JetFile: SimpleExpressions.jet PsiElement(EQ)('=') PsiWhiteSpace(' ') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(LT)('<') TYPE_REFERENCE USER_TYPE diff --git a/idea/testData/psi/examples/BinaryTree.txt b/idea/testData/psi/examples/BinaryTree.txt index a550a3bfef3..6b67228916b 100644 --- a/idea/testData/psi/examples/BinaryTree.txt +++ b/idea/testData/psi/examples/BinaryTree.txt @@ -180,7 +180,8 @@ JetFile: BinaryTree.jet BINARY_EXPRESSION DOT_QUALIFIED_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('compare') @@ -286,7 +287,8 @@ JetFile: BinaryTree.jet PsiElement(LPAR)('(') VALUE_ARGUMENT THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(COMMA)(',') PsiWhiteSpace(' ') VALUE_ARGUMENT @@ -1897,7 +1899,8 @@ JetFile: BinaryTree.jet PsiElement(IDENTIFIER)('BinaryTree') PsiElement(DOT)('.') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('version') @@ -2475,7 +2478,8 @@ JetFile: BinaryTree.jet PsiElement(IDENTIFIER)('BinaryTree') PsiElement(DOT)('.') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('version') @@ -2520,7 +2524,8 @@ JetFile: BinaryTree.jet PsiElement(IDENTIFIER)('BinaryTree') PsiElement(DOT)('.') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('version') diff --git a/idea/testData/psi/examples/BitArith.txt b/idea/testData/psi/examples/BitArith.txt index 97a62fdee77..31041265802 100644 --- a/idea/testData/psi/examples/BitArith.txt +++ b/idea/testData/psi/examples/BitArith.txt @@ -499,7 +499,8 @@ JetFile: BitArith.jet BINARY_EXPRESSION BINARY_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(IDENTIFIER)('and') diff --git a/idea/testData/psi/examples/PolymorphicClassObjects.txt b/idea/testData/psi/examples/PolymorphicClassObjects.txt index af916c0e519..0f6b406c866 100644 --- a/idea/testData/psi/examples/PolymorphicClassObjects.txt +++ b/idea/testData/psi/examples/PolymorphicClassObjects.txt @@ -363,7 +363,8 @@ JetFile: PolymorphicClassObjects.jet PsiWhiteSpace(' ') LOOP_RANGE THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(RPAR)(')') PsiWhiteSpace(' ') BODY diff --git a/idea/testData/psi/examples/UnionFind.txt b/idea/testData/psi/examples/UnionFind.txt index 2bdfe60746e..e145b6423f5 100644 --- a/idea/testData/psi/examples/UnionFind.txt +++ b/idea/testData/psi/examples/UnionFind.txt @@ -388,7 +388,8 @@ JetFile: UnionFind.jet BINARY_EXPRESSION BINARY_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(PERC)('%') diff --git a/idea/testData/psi/examples/collections/ArrayList.txt b/idea/testData/psi/examples/collections/ArrayList.txt index eb757b554b7..997df3f7c86 100644 --- a/idea/testData/psi/examples/collections/ArrayList.txt +++ b/idea/testData/psi/examples/collections/ArrayList.txt @@ -350,7 +350,8 @@ JetFile: ArrayList.jet PsiElement(IDENTIFIER)('ArrayList') PsiElement(DOT)('.') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') CALL_EXPRESSION REFERENCE_EXPRESSION diff --git a/idea/testData/psi/examples/collections/HashMap.txt b/idea/testData/psi/examples/collections/HashMap.txt index a4ff6f08621..e44b6f58ef9 100644 --- a/idea/testData/psi/examples/collections/HashMap.txt +++ b/idea/testData/psi/examples/collections/HashMap.txt @@ -44,7 +44,8 @@ JetFile: HashMap.jet PsiElement(LPAR)('(') BINARY_WITH_TYPE THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(as)('as') @@ -138,7 +139,8 @@ JetFile: HashMap.jet PsiElement(LPAR)('(') BINARY_WITH_TYPE THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(as)('as') @@ -373,7 +375,8 @@ JetFile: HashMap.jet PsiElement(LPAR)('(') VALUE_ARGUMENT THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(RPAR)(')') PsiWhiteSpace('\n\n') CLASS diff --git a/idea/testData/psi/examples/collections/List.txt b/idea/testData/psi/examples/collections/List.txt index 970e2fbc219..61a1d9fcd16 100644 --- a/idea/testData/psi/examples/collections/List.txt +++ b/idea/testData/psi/examples/collections/List.txt @@ -202,7 +202,8 @@ JetFile: List.jet PsiWhiteSpace(' ') BINARY_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(EQEQ)('==') @@ -256,7 +257,8 @@ JetFile: List.jet PsiElement(IDENTIFIER)('List') PsiElement(DOT)('.') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace('\n\n ') PROPERTY MODIFIER_LIST diff --git a/idea/testData/psi/examples/priorityqueues/BinaryHeap.txt b/idea/testData/psi/examples/priorityqueues/BinaryHeap.txt index 2db7592495f..9eea2a5f1cf 100644 --- a/idea/testData/psi/examples/priorityqueues/BinaryHeap.txt +++ b/idea/testData/psi/examples/priorityqueues/BinaryHeap.txt @@ -138,7 +138,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION DOT_QUALIFIED_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('compare') @@ -152,7 +153,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION DOT_QUALIFIED_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('data') @@ -254,7 +256,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION DOT_QUALIFIED_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('compare') @@ -268,7 +271,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION DOT_QUALIFIED_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('data') @@ -297,7 +301,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION DOT_QUALIFIED_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('data') @@ -343,7 +348,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION DOT_QUALIFIED_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('comparator') @@ -393,7 +399,8 @@ JetFile: BinaryHeap.jet CONDITION DOT_QUALIFIED_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('isEmpty') @@ -942,7 +949,8 @@ JetFile: BinaryHeap.jet PsiElement(LPAR)('(') BINARY_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(MINUS)('-') @@ -979,7 +987,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION BINARY_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(MUL)('*') @@ -1015,7 +1024,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION BINARY_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(MUL)('*') @@ -1067,7 +1077,8 @@ JetFile: BinaryHeap.jet INDICES PsiElement(LBRACKET)('[') THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(RBRACKET)(']') PsiWhiteSpace('\n ') PROPERTY_ACCESSOR @@ -1117,7 +1128,8 @@ JetFile: BinaryHeap.jet PsiElement(LPAR)('(') BINARY_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(LT)('<') @@ -1137,7 +1149,8 @@ JetFile: BinaryHeap.jet PsiElement(LPAR)('(') BINARY_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(GTEQ)('>=') @@ -1209,7 +1222,8 @@ JetFile: BinaryHeap.jet PsiElement(LPAR)('(') VALUE_ARGUMENT THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(COMMA)(',') PsiWhiteSpace(' ') VALUE_ARGUMENT @@ -1274,7 +1288,8 @@ JetFile: BinaryHeap.jet PsiWhiteSpace(' ') ARRAY_ACCESS_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') INDICES PsiElement(LBRACKET)('[') REFERENCE_EXPRESSION @@ -1284,7 +1299,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION ARRAY_ACCESS_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') INDICES PsiElement(LBRACKET)('[') REFERENCE_EXPRESSION @@ -1296,7 +1312,8 @@ JetFile: BinaryHeap.jet PsiWhiteSpace(' ') ARRAY_ACCESS_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') INDICES PsiElement(LBRACKET)('[') REFERENCE_EXPRESSION @@ -1306,7 +1323,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION ARRAY_ACCESS_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') INDICES PsiElement(LBRACKET)('[') REFERENCE_EXPRESSION @@ -1356,7 +1374,8 @@ JetFile: BinaryHeap.jet BINARY_EXPRESSION DOT_QUALIFIED_EXPRESSION THIS_EXPRESSION - PsiElement(this)('this') + REFERENCE_EXPRESSION + PsiElement(this)('this') PsiElement(DOT)('.') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('size') diff --git a/idea/testData/resolve/Classifiers.jet b/idea/testData/resolve/Classifiers.jet index d9dfa80d85e..026ba3a96e1 100644 --- a/idea/testData/resolve/Classifiers.jet +++ b/idea/testData/resolve/Classifiers.jet @@ -2,8 +2,13 @@ namespace qualified_this { ~qtA~class A(val a:Int) { ~qtB~class B() { - val x = this`qtB`@B - val y = this`qtA`@A + val x = `qtB`this`qtB`@B + val y = `qtA`this`qtA`@A + val z = `qtB`this + ~xx~val Int.xx = `xx`this : Int + ~xx()~fun Int.xx() { + `xx()`this : Int + } } } } diff --git a/idea/tests/org/jetbrains/jet/JetTestUtils.java b/idea/tests/org/jetbrains/jet/JetTestUtils.java index 7bc454cc2d0..bc6651ad18c 100644 --- a/idea/tests/org/jetbrains/jet/JetTestUtils.java +++ b/idea/tests/org/jetbrains/jet/JetTestUtils.java @@ -178,6 +178,7 @@ public class JetTestUtils { public Collection getDiagnostics() { throw new UnsupportedOperationException(); // TODO } + }; } };