From c40d0fce246355f25afe107fa9add0d00b459ae8 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Sat, 5 Mar 2011 16:12:45 +0300 Subject: [PATCH] Fully-qualified names of Java elements supported --- .../jet/codegen/NamespaceCodegen.java | 20 +++-------- .../org/jetbrains/jet/lang/ErrorHandler.java | 9 +++++ .../jet/lang/JetSemanticServices.java | 2 +- .../jet/lang/annotations/JetPsiChecker.java | 26 ++++---------- .../jet/lang/psi/JetImportDirective.java | 14 ++++++-- .../jet/lang/psi/JetReferenceExpression.java | 19 ++-------- .../jet/lang/resolve/AnalyzingUtils.java | 35 +++++++++++++++++++ .../jet/lang/resolve/ScopeWithImports.java | 8 ++--- .../jet/lang/resolve/ScopeWithReceiver.java | 2 +- .../jet/lang/resolve/TopDownAnalyzer.java | 33 ++++++++++++++--- .../resolve/java/JavaDescriptorResolver.java | 19 ++++++++-- ...vaLangScope.java => JavaPackageScope.java} | 8 +++-- .../jet/lang/types/JetStandardLibrary.java | 17 +++++++-- .../jet/lang/types/JetTypeInferrer.java | 7 ++-- .../jet/resolve/ExpectedResolveData.java | 8 ++--- .../jet/types/JetTypeCheckerTest.java | 2 +- 16 files changed, 150 insertions(+), 79 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java rename idea/src/org/jetbrains/jet/lang/resolve/java/{JavaLangScope.java => JavaPackageScope.java} (73%) diff --git a/idea/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/idea/src/org/jetbrains/jet/codegen/NamespaceCodegen.java index de8d7fa21c9..15f6a76cad1 100644 --- a/idea/src/org/jetbrains/jet/codegen/NamespaceCodegen.java +++ b/idea/src/org/jetbrains/jet/codegen/NamespaceCodegen.java @@ -2,19 +2,16 @@ package org.jetbrains.jet.codegen; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.ErrorHandler; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFunction; import org.jetbrains.jet.lang.psi.JetNamespace; import org.jetbrains.jet.lang.psi.JetProperty; -import org.jetbrains.jet.lang.resolve.*; -import org.jetbrains.jet.lang.resolve.java.JavaLangScope; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.AnalyzingUtils; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.types.JetStandardLibrary; import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.Opcodes; -import java.util.List; - /** * @author max */ @@ -23,17 +20,10 @@ public class NamespaceCodegen { } public void generate(JetNamespace namespace, ClassVisitor v, Project project) { - List declarations = namespace.getDeclarations(); - - JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project, ErrorHandler.THROW_EXCEPTION); - BindingTraceContext bindingTraceContext = new BindingTraceContext(); - ScopeWithImports scope = new ScopeWithImports(semanticServices.getStandardLibrary().getLibraryScope()); - scope.addImport(new JavaLangScope(new JavaSemanticServices(project, semanticServices, bindingTraceContext))); - new TopDownAnalyzer(semanticServices, bindingTraceContext).process(scope, declarations); - BindingContext bindingContext = bindingTraceContext; + BindingContext bindingContext = AnalyzingUtils.analyzeNamespace(namespace, ErrorHandler.THROW_EXCEPTION); final PropertyCodegen propertyCodegen = new PropertyCodegen(v); - final FunctionCodegen functionCodegen = new FunctionCodegen(v, semanticServices.getStandardLibrary(), bindingContext); + final FunctionCodegen functionCodegen = new FunctionCodegen(v, JetStandardLibrary.getJetStandardLibrary(project), bindingContext); v.visit(Opcodes.V1_6, Opcodes.ACC_PUBLIC, getJVMClassName(namespace), diff --git a/idea/src/org/jetbrains/jet/lang/ErrorHandler.java b/idea/src/org/jetbrains/jet/lang/ErrorHandler.java index 5f8192aa4de..f493e04c086 100644 --- a/idea/src/org/jetbrains/jet/lang/ErrorHandler.java +++ b/idea/src/org/jetbrains/jet/lang/ErrorHandler.java @@ -1,5 +1,6 @@ package org.jetbrains.jet.lang; +import com.intellij.lang.ASTNode; import org.jetbrains.jet.lang.psi.JetReferenceExpression; /** @@ -12,8 +13,16 @@ public class ErrorHandler { public void unresolvedReference(JetReferenceExpression referenceExpression) { throw new IllegalStateException("Unresolved reference: " + referenceExpression.getReferencedName()); } + + @Override + public void structuralError(ASTNode node, String errorMessage) { + throw new IllegalStateException(errorMessage); + } }; public void unresolvedReference(JetReferenceExpression referenceExpression) { } + + public void structuralError(ASTNode node, String errorMessage) { + } } diff --git a/idea/src/org/jetbrains/jet/lang/JetSemanticServices.java b/idea/src/org/jetbrains/jet/lang/JetSemanticServices.java index 1ad60a093e3..1986f329b43 100644 --- a/idea/src/org/jetbrains/jet/lang/JetSemanticServices.java +++ b/idea/src/org/jetbrains/jet/lang/JetSemanticServices.java @@ -15,7 +15,7 @@ public class JetSemanticServices { } public static JetSemanticServices createSemanticServices(Project project, ErrorHandler errorHandler) { - return new JetSemanticServices(new JetStandardLibrary(project), errorHandler); + return new JetSemanticServices(JetStandardLibrary.getJetStandardLibrary(project), errorHandler); } private final JetTypeInferrer typeInferrer; diff --git a/idea/src/org/jetbrains/jet/lang/annotations/JetPsiChecker.java b/idea/src/org/jetbrains/jet/lang/annotations/JetPsiChecker.java index cb1a4c2bfef..902f76213da 100644 --- a/idea/src/org/jetbrains/jet/lang/annotations/JetPsiChecker.java +++ b/idea/src/org/jetbrains/jet/lang/annotations/JetPsiChecker.java @@ -7,14 +7,9 @@ import com.intellij.openapi.util.TextRange; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.ErrorHandler; -import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.ScopeWithImports; -import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; -import org.jetbrains.jet.lang.resolve.java.JavaLangScope; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.types.Type; /** @@ -28,20 +23,13 @@ public class JetPsiChecker implements Annotator { Project project = element.getProject(); JetFile file = (JetFile) element; - JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(element.getProject(), new ErrorHandler() { - @Override - public void unresolvedReference(JetReferenceExpression referenceExpression) { - holder.createErrorAnnotation(referenceExpression, "Unresolved"); - } - }); try { - ScopeWithImports scope = new ScopeWithImports(semanticServices.getStandardLibrary().getLibraryScope()); - BindingTraceContext bindingTraceContext = new BindingTraceContext(); - scope.addImport(new JavaLangScope(new JavaSemanticServices(project, semanticServices, bindingTraceContext))); - new TopDownAnalyzer(semanticServices, bindingTraceContext).process( - scope, - file.getRootNamespace().getDeclarations()); - final BindingContext bindingContext = bindingTraceContext; + final BindingContext bindingContext = AnalyzingUtils.analyzeFile(file, new ErrorHandler() { + @Override + public void unresolvedReference(JetReferenceExpression referenceExpression) { + holder.createErrorAnnotation(referenceExpression, "Unresolved"); + } + }); file.getRootNamespace().accept(new JetVisitor() { @Override public void visitClass(JetClass klass) { diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetImportDirective.java b/idea/src/org/jetbrains/jet/lang/psi/JetImportDirective.java index 34e292260e1..980837ff222 100644 --- a/idea/src/org/jetbrains/jet/lang/psi/JetImportDirective.java +++ b/idea/src/org/jetbrains/jet/lang/psi/JetImportDirective.java @@ -35,22 +35,30 @@ public class JetImportDirective extends JetElement { } @Nullable - public String getAliasName() { + private ASTNode getAliasNameNode() { boolean asPassed = false; ASTNode childNode = getNode().getFirstChildNode(); while (childNode != null) { IElementType tt = childNode.getElementType(); if (tt == JetTokens.AS_KEYWORD) asPassed = true; if (asPassed && tt == JetTokens.IDENTIFIER) { - return childNode.getText(); + return childNode; } childNode = childNode.getTreeNext(); } - return null; } + @Nullable + public String getAliasName() { + ASTNode aliasNameNode = getAliasNameNode(); + if (aliasNameNode == null) { + return null; + } + return aliasNameNode.getText(); + } + public boolean isAllUnder() { return getNode().findChildByType(JetTokens.MAP) != null; } diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetReferenceExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetReferenceExpression.java index 35439d2f1fd..a31c73b3098 100644 --- a/idea/src/org/jetbrains/jet/lang/psi/JetReferenceExpression.java +++ b/idea/src/org/jetbrains/jet/lang/psi/JetReferenceExpression.java @@ -9,13 +9,7 @@ import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.ErrorHandler; -import org.jetbrains.jet.lang.JetSemanticServices; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.ScopeWithImports; -import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; -import org.jetbrains.jet.lang.resolve.java.JavaLangScope; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lexer.JetTokens; /** @@ -71,15 +65,7 @@ public class JetReferenceExpression extends JetExpression { element = element.getParent(); } JetFile file = (JetFile) element; - JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(element.getProject(), ErrorHandler.DO_NOTHING); - - ScopeWithImports scope = new ScopeWithImports(semanticServices.getStandardLibrary().getLibraryScope()); - - BindingTraceContext bindingTraceContext = new BindingTraceContext(); - scope.addImport(new JavaLangScope(new JavaSemanticServices(element.getProject(), semanticServices, bindingTraceContext))); - - new TopDownAnalyzer(semanticServices, bindingTraceContext).process(scope, file.getRootNamespace().getDeclarations()); - BindingContext bindingContext = bindingTraceContext; + BindingContext bindingContext = AnalyzingUtils.analyzeFile(file, ErrorHandler.DO_NOTHING); return bindingContext.resolveToDeclarationPsiElement(JetReferenceExpression.this); } @@ -116,4 +102,5 @@ public class JetReferenceExpression extends JetExpression { } }; } + } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java b/idea/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java new file mode 100644 index 00000000000..f11a18d5e82 --- /dev/null +++ b/idea/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java @@ -0,0 +1,35 @@ +package org.jetbrains.jet.lang.resolve; + +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.ErrorHandler; +import org.jetbrains.jet.lang.JetSemanticServices; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetNamespace; +import org.jetbrains.jet.lang.resolve.java.JavaPackageScope; +import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; + +/** + * @author abreslav + */ +public class AnalyzingUtils { + public static BindingContext analyzeFile(@NotNull JetFile file, @NotNull ErrorHandler errorHandler) { + JetNamespace rootNamespace = file.getRootNamespace(); + return analyzeNamespace(rootNamespace, errorHandler); + } + + public static BindingContext analyzeNamespace(@NotNull JetNamespace namespace, @NotNull ErrorHandler errorHandler) { + Project project = namespace.getProject(); + JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project, errorHandler); + + BindingTraceContext bindingTraceContext = new BindingTraceContext(); + JavaSemanticServices javaSemanticServices = new JavaSemanticServices(project, semanticServices, bindingTraceContext); + + ScopeWithImports scope = new ScopeWithImports(semanticServices.getStandardLibrary().getLibraryScope()); + scope.importScope(new JavaPackageScope("", javaSemanticServices)); + scope.importScope(new JavaPackageScope("java.lang", javaSemanticServices)); + + new TopDownAnalyzer(semanticServices, bindingTraceContext).process(scope, namespace); + return bindingTraceContext; + } +} diff --git a/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithImports.java b/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithImports.java index dfa862f5708..4b36c36c72e 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithImports.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithImports.java @@ -18,7 +18,7 @@ public class ScopeWithImports implements JetScope { this.scope = scope; } - public void addImport(JetScope imported) { + public void importScope(JetScope imported) { imports.add(0, imported); } @@ -68,18 +68,18 @@ public class ScopeWithImports implements JetScope { @Override public TypeParameterDescriptor getTypeParameter(@NotNull String name) { - throw new UnsupportedOperationException(); // TODO + return scope.getTypeParameter(name); } @NotNull @Override public Type getThisType() { - throw new UnsupportedOperationException(); // TODO + return scope.getThisType(); } @NotNull @Override public FunctionGroup getFunctionGroup(@NotNull String name) { - throw new UnsupportedOperationException(); // TODO + return scope.getFunctionGroup(name); // TODO } } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java b/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java index af1ab449f65..8a9763272a2 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java @@ -34,7 +34,7 @@ public class ScopeWithReceiver extends JetScopeImpl { @Override public NamespaceDescriptor getNamespace(@NotNull String name) { - return outerScope.getNamespace(name); + return receiverTypeScope.getNamespace(name); } @Override diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 04eb59a1c9a..ab735608a65 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -5,10 +5,7 @@ import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.types.*; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; +import java.util.*; /** * @author abreslav @@ -29,6 +26,10 @@ public class TopDownAnalyzer { this.trace = bindingTrace; } + public void process(@NotNull JetScope outerScope, @NotNull JetDeclaration declaration) { + process(outerScope, Collections.singletonList(declaration)); + } + public void process(@NotNull JetScope outerScope, @NotNull List declarations) { final WritableScope toplevelScope = new WritableScope(outerScope); trace.setToplevelScope(toplevelScope); // TODO : this is a hack @@ -51,6 +52,27 @@ public class TopDownAnalyzer { collectTypeDeclarators(classScope, klass.getDeclarations()); } + @Override + public void visitNamespace(JetNamespace namespace) { + List importDirectives = namespace.getImportDirectives(); + + ScopeWithImports scopeWithImports = new ScopeWithImports(declaringScope); + + for (JetImportDirective importDirective : importDirectives) { +// if (importDirective.isAllUnder()) { +// // TODO: this works only for Java, +// // but should thoroughly resolve qualified names item-by-item +// // taking previous imports into account +// String importedName = importDirective.getImportedName(); +// scopeWithImports.importScope(new JavaPackageScope(importedName, )); +// } else { +// throw new UnsupportedOperationException(); +// } + } + WritableScope namespaceScope = new WritableScope(scopeWithImports); + collectTypeDeclarators(namespaceScope, namespace.getDeclarations()); + } + @Override public void visitTypedef(JetTypedef typedef) { processTypeDef(typedef); @@ -67,10 +89,13 @@ public class TopDownAnalyzer { private WritableScope processClass(@NotNull WritableScope declaringScope, JetClass klass) { MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(declaringScope); mutableClassDescriptor.setName(klass.getName()); + declaringScope.addClassDescriptor(mutableClassDescriptor); + classes.put(klass, mutableClassDescriptor); trace.recordDeclarationResolution(klass, mutableClassDescriptor); declaringScopes.put(klass, declaringScope); + return mutableClassDescriptor.getUnsubstitutedMemberScope(); } 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 2ece3556607..36ff5718d28 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -73,14 +73,29 @@ public class JavaDescriptorResolver { PsiClass psiClass = javaFacade.findClass(qualifiedName, javaSearchScope); if (psiClass == null) { - return null; + PsiPackage psiPackage = javaFacade.findPackage(qualifiedName); + if (psiPackage == null) { + return null; + } + namespaceDescriptor = createJavaNamespaceDescriptor(psiPackage); + } else { + namespaceDescriptor = createJavaNamespaceDescriptor(psiClass); } - namespaceDescriptor = createJavaNamespaceDescriptor(psiClass); namespaceDescriptorCache.put(qualifiedName, namespaceDescriptor); } return namespaceDescriptor; } + private NamespaceDescriptor createJavaNamespaceDescriptor(PsiPackage psiPackage) { + NamespaceDescriptor namespaceDescriptor = new NamespaceDescriptor( + Collections.emptyList(), // TODO + psiPackage.getName(), + new JavaPackageScope(psiPackage.getQualifiedName(), semanticServices) + ); + semanticServices.getTrace().recordDeclarationResolution(psiPackage, namespaceDescriptor); + return namespaceDescriptor; + } + private NamespaceDescriptor createJavaNamespaceDescriptor(@NotNull PsiClass psiClass) { NamespaceDescriptor namespaceDescriptor = new NamespaceDescriptor( Collections.emptyList(), // TODO diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaLangScope.java b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java similarity index 73% rename from idea/src/org/jetbrains/jet/lang/resolve/java/JavaLangScope.java rename to idea/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java index 11c24908a7c..640b5f9ab0d 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaLangScope.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java @@ -8,12 +8,14 @@ import org.jetbrains.jet.lang.types.NamespaceDescriptor; /** * @author abreslav */ -public class JavaLangScope extends JetScopeImpl { +public class JavaPackageScope extends JetScopeImpl { private final JavaSemanticServices semanticServices; + private String packagePrefix; - public JavaLangScope(JavaSemanticServices semanticServices) { + public JavaPackageScope(@NotNull String packageFQN, JavaSemanticServices semanticServices) { this.semanticServices = semanticServices; + this.packagePrefix = packageFQN.isEmpty() ? "" : packageFQN + "."; } @Override @@ -27,6 +29,6 @@ public class JavaLangScope extends JetScopeImpl { } private String getQualifiedName(String name) { - return "java.lang." + name; + return packagePrefix + name; } } diff --git a/idea/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java b/idea/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java index 02506c313be..c777c734a55 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java @@ -16,14 +16,27 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; +import java.util.HashMap; +import java.util.Map; /** * @author abreslav */ public class JetStandardLibrary { - private final JetScope libraryScope; + // TODO : consider releasing this memory + private static final Map standardLibraryCache = new HashMap(); + public static JetStandardLibrary getJetStandardLibrary(@NotNull Project project) { + JetStandardLibrary standardLibrary = standardLibraryCache.get(project); + if (standardLibrary == null) { + standardLibrary = new JetStandardLibrary(project); + standardLibraryCache.put(project, standardLibrary); + } + return standardLibrary; + } + + private final JetScope libraryScope; private final ClassDescriptor byteClass; private final ClassDescriptor charClass; private final ClassDescriptor shortClass; @@ -44,7 +57,7 @@ public class JetStandardLibrary { private final Type booleanType; private final Type stringType; - public JetStandardLibrary(@NotNull Project project) { + private JetStandardLibrary(@NotNull Project project) { // TODO : review InputStream stream = JetStandardClasses.class.getClassLoader().getResourceAsStream("jet/lang/Library.jet"); try { diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index b401fd8f6c2..187fcbbbc94 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -381,8 +381,10 @@ public class JetTypeInferrer { JetReferenceExpression referenceExpression = (JetReferenceExpression) selectorExpression; Type receiverType = getType(scope, expression.getReceiverExpression(), false); - result[0] = OverloadResolver.INSTANCE.getOverloadDomain(receiverType, scope, referenceExpression.getReferencedName()); - reference[0] = referenceExpression; + if (receiverType != null) { + result[0] = OverloadResolver.INSTANCE.getOverloadDomain(receiverType, scope, referenceExpression.getReferencedName()); + reference[0] = referenceExpression; + } } else { throw new UnsupportedOperationException(); // TODO } @@ -406,6 +408,7 @@ public class JetTypeInferrer { throw new IllegalArgumentException("Unsupported element: " + elem); } }); + if (result[0] == null) return OverloadDomain.EMPTY; return new OverloadDomain() { @Override public FunctionDescriptor getFunctionDescriptorForNamedArguments(@NotNull List typeArguments, @NotNull Map valueArgumentTypes, @Nullable Type functionLiteralArgumentType) { diff --git a/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java index aaa924af4ce..17974f7f845 100644 --- a/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java +++ b/idea/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java @@ -6,9 +6,8 @@ import com.intellij.psi.PsiElement; import org.jetbrains.jet.lang.ErrorHandler; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; import org.jetbrains.jet.lang.types.*; import java.util.Collection; @@ -77,10 +76,7 @@ public class ExpectedResolveData { Map nameToDescriptor = new HashMap(); nameToDescriptor.put("std::Int.plus(Int)", standardFunction(lib.getInt(), "plus", lib.getIntType())); - BindingTraceContext bindingTraceContext = new BindingTraceContext(); - TopDownAnalyzer topDownAnalyzer = new TopDownAnalyzer(semanticServices, bindingTraceContext); - topDownAnalyzer.process(lib.getLibraryScope(), file.getRootNamespace().getDeclarations()); - BindingContext bindingContext = bindingTraceContext; + BindingContext bindingContext = AnalyzingUtils.analyzeFile(file, ErrorHandler.THROW_EXCEPTION); Map nameToDeclaration = new HashMap(); diff --git a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index d6e7911e967..2edc4cbffc8 100644 --- a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -32,7 +32,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase { @Override public void setUp() throws Exception { super.setUp(); - library = new JetStandardLibrary(getProject()); + library = JetStandardLibrary.getJetStandardLibrary(getProject()); semanticServices = JetSemanticServices.createSemanticServices(library, ErrorHandler.DO_NOTHING); classDefinitions = new ClassDefinitions(); classDescriptorResolver = semanticServices.getClassDescriptorResolver(BindingTrace.DUMMY);