From 30e44fdc5f4efbed4f113d4bb2d70ecc6c7f4d61 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Mon, 28 May 2012 20:30:23 +0400 Subject: [PATCH] script parameters still a lot of things to do --- .../jet/buildtools/core/BytecodeCompiler.java | 2 +- .../jetbrains/jet/codegen/CodegenContext.java | 4 + .../jet/codegen/CodegenContexts.java | 21 ++ .../jet/codegen/GenerationState.java | 13 ++ .../jetbrains/jet/codegen/JetTypeMapper.java | 22 ++ .../jetbrains/jet/codegen/ScriptCodegen.java | 28 ++- .../jetbrains/jet/cli/jvm/K2JVMCompiler.java | 12 +- .../jvm/compiler/CommandLineScriptUtils.java | 40 ++++ .../jvm/compiler/CompileEnvironmentUtil.java | 3 +- .../K2JVMCompileEnvironmentConfiguration.java | 16 +- .../compiler/KotlinToJVMBytecodeCompiler.java | 15 +- .../di/InjectorForTopDownAnalyzerForJvm.java | 32 ++- .../resolve/java/AnalyzerFacadeForJVM.java | 39 ++-- .../jet/analyzer/AnalyzerFacade.java | 4 + .../di/InjectorForTopDownAnalyzerBasic.java | 17 ++ .../lang/descriptors/ScriptDescriptor.java | 10 +- .../lang/resolve/AnalyzerScriptParameter.java | 46 +++++ .../jet/lang/resolve/BodyResolver.java | 98 ++++++--- .../jet/lang/resolve/ScriptResolver.java | 195 ++++++++++++++++++ .../resolve/TopDownAnalysisParameters.java | 13 +- .../jet/lang/resolve/TopDownAnalyzer.java | 25 ++- .../lang/resolve/TypeHierarchyResolver.java | 21 +- .../jet/lang/resolve/TypeResolver.java | 1 + .../jetbrains/jet/lang/types/TypeUtils.java | 19 ++ .../data/script/hello.ktscript | 4 +- .../data/script/script.expected | 3 +- .../jetbrains/kotlin/CompilerSmokeTest.java | 2 +- .../codegen/script/parameter.ktscript | 5 + .../codegen/script/parameterArray.ktscript | 4 + .../codegen/script/parameterLong.ktscript | 5 + .../tests/org/jetbrains/jet/JetTestUtils.java | 3 +- .../jet/checkers/CheckerTestUtilTest.java | 4 +- .../jet/checkers/JetDiagnosticsTest.java | 7 +- .../jvm/compiler/ReadJavaBinaryClassTest.java | 4 +- .../jet/codegen/CodegenTestCase.java | 66 +++++- .../jet/codegen/CodegenTestFile.java | 68 +++++- .../jet/codegen/CompileTextTest.java | 3 +- .../jet/codegen/GenerationUtils.java | 4 +- .../jetbrains/jet/codegen/ScriptGenTest.java | 12 ++ .../jetbrains/jet/codegen/TestlibTest.java | 3 +- .../jet/resolve/DescriptorRendererTest.java | 5 +- .../jet/resolve/ExpectedResolveData.java | 7 +- .../JetDefaultModalityModifiersTest.java | 3 + .../libraries/JetSourceNavigationHelper.java | 2 + .../project/AnalyzerFacadeWithCache.java | 3 + .../project/JSAnalyzerFacadeForIDEA.java | 4 + .../jet/di/AllInjectorsGenerator.java | 2 + .../di/InjectorForTopDownAnalyzerForJs.java | 14 ++ .../k2js/analyze/AnalyzerFacadeForJS.java | 8 +- 49 files changed, 833 insertions(+), 108 deletions(-) create mode 100644 compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CommandLineScriptUtils.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzerScriptParameter.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptResolver.java create mode 100644 compiler/testData/codegen/script/parameter.ktscript create mode 100644 compiler/testData/codegen/script/parameterArray.ktscript create mode 100644 compiler/testData/codegen/script/parameterLong.ktscript diff --git a/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java b/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java index ef2fd970e5e..7471bfdb3c9 100644 --- a/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java +++ b/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java @@ -54,7 +54,7 @@ public class BytecodeCompiler { CompilerDependencies dependencies = CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR); JetCoreEnvironment environment = new JetCoreEnvironment(CompileEnvironmentUtil.createMockDisposable(), dependencies); K2JVMCompileEnvironmentConfiguration - env = new K2JVMCompileEnvironmentConfiguration(environment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR); + env = new K2JVMCompileEnvironmentConfiguration(environment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR, false, Collections.emptyList()); if (( stdlib != null ) && ( stdlib.trim().length() > 0 )) { File file = new File(stdlib); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java index 11969ba40d7..d9d078fe28e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java @@ -125,6 +125,10 @@ public abstract class CodegenContext { return new CodegenContexts.ConstructorContext(descriptor, getContextKind(), this, typeMapper); } + public CodegenContext intoScript(ScriptDescriptor script) { + return new CodegenContexts.ScriptContext(script, OwnerKind.IMPLEMENTATION, this, closure); + } + public CodegenContexts.ClosureContext intoClosure(FunctionDescriptor funDescriptor, ClassDescriptor classDescriptor, String internalClassName, ClosureCodegen closureCodegen, JetTypeMapper typeMapper) { return new CodegenContexts.ClosureContext(funDescriptor, classDescriptor, this, closureCodegen, internalClassName, typeMapper); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContexts.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContexts.java index 283d26ff222..c7d35796750 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContexts.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContexts.java @@ -118,6 +118,27 @@ public class CodegenContexts { } } + public static class ScriptContext extends CodegenContext { + + public ScriptContext( + @NotNull DeclarationDescriptor contextType, + @NotNull OwnerKind contextKind, + @Nullable CodegenContext parentContext, + @Nullable ObjectOrClosureCodegen closureCodegen) { + super(contextType, contextKind, parentContext, closureCodegen); + } + + @Override + protected ClassDescriptor getThisDescriptor() { + return null; + } + + @Override + public boolean isStatic() { + throw new IllegalStateException(); + } + } + public static class ClassContext extends CodegenContext { public ClassContext(ClassDescriptor contextType, OwnerKind contextKind, CodegenContext parentContext, JetTypeMapper typeMapper) { super(contextType, contextKind, parentContext, null); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java b/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java index b90334d6ec2..e40f788a295 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java @@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.utils.Progress; +import org.objectweb.asm.commons.Method; import java.util.List; @@ -54,6 +55,10 @@ public class GenerationState { private final ClassBuilderMode classBuilderMode; + // out parameter + private Method scriptConstructorMethod; + + public GenerationState(Project project, ClassBuilderFactory builderFactory, AnalyzeExhaust analyzeExhaust, List files) { this(project, builderFactory, Progress.DEAF, analyzeExhaust, files, CompilerSpecialMode.REGULAR); } @@ -92,6 +97,14 @@ public class GenerationState { return classBuilderMode; } + public void setScriptConstructorMethod(@NotNull Method scriptConstructorMethod) { + this.scriptConstructorMethod = scriptConstructorMethod; + } + + public Method getScriptConstructorMethod() { + return scriptConstructorMethod; + } + public ClassBuilder forClassImplementation(ClassDescriptor aClass) { return getFactory().newVisitor(getInjector().getJetTypeMapper().mapType(aClass.getDefaultType(), MapTypeMode.IMPL).getInternalName() + ".class"); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 71bc4f14ec5..f11d4446828 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -871,6 +871,27 @@ public class JetTypeMapper { return signatureWriter.makeJvmMethodSignature(""); } + @NotNull + public JvmMethodSignature mapScriptSignature(@NotNull ScriptDescriptor script) { + BothSignatureWriter signatureWriter = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD, false); + + writeFormalTypeParameters(Collections.emptyList(), signatureWriter); + + signatureWriter.writeParametersStart(); + + for (ValueParameterDescriptor valueParameter : script.getValueParameters()) { + signatureWriter.writeParameterType(JvmMethodParameterKind.VALUE); + mapType(valueParameter.getType(), signatureWriter, MapTypeMode.VALUE); + signatureWriter.writeParameterTypeEnd(); + } + + signatureWriter.writeParametersEnd(); + + signatureWriter.writeVoidReturn(); + + return signatureWriter.makeJvmMethodSignature(""); + } + public CallableMethod mapToCallableMethod(ConstructorDescriptor descriptor, OwnerKind kind, boolean hasThis0) { final JvmMethodSignature method = mapConstructorSignature(descriptor, hasThis0); MapTypeMode mapTypeMode = ownerKindToMapTypeMode(kind); @@ -883,6 +904,7 @@ public class JetTypeMapper { return new CallableMethod(owner, owner, owner, method, INVOKESPECIAL); } + public static int getAccessModifiers(MemberDescriptor p, int defaultFlags) { DeclarationDescriptor declaration = p.getContainingDeclaration(); if(CodegenUtil.isInterface(declaration)) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java index e412b19799d..53fac5e943d 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java @@ -17,7 +17,9 @@ package org.jetbrains.jet.codegen; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.codegen.signature.JvmMethodSignature; import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.psi.JetScript; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.JdkNames; @@ -60,7 +62,7 @@ public class ScriptCodegen { - public void generate(CodegenContext context, JetScript scriptDeclaration) { + public void generate(CodegenContext outerContext, JetScript scriptDeclaration) { ScriptDescriptor scriptDescriptor = (ScriptDescriptor) state.getBindingContext().get(BindingContext.SCRIPT, scriptDeclaration); ClassBuilder classBuilder = classFileFactory.newVisitor("Script.class"); classBuilder.defineClass(scriptDeclaration, @@ -75,7 +77,12 @@ public class ScriptCodegen { classBuilder.newField(null, Opcodes.ACC_PUBLIC, LAST_EXPRESSION_VALUE_FIELD_NAME, blockType.getDescriptor(), null, null); - MethodVisitor mv = classBuilder.newMethod(scriptDeclaration, Opcodes.ACC_PUBLIC, "", "()V", null, null); + JvmMethodSignature jvmSignature = jetTypeMapper.mapScriptSignature(scriptDescriptor); + + state.setScriptConstructorMethod(jvmSignature.getAsmMethod()); + + MethodVisitor mv = classBuilder.newMethod( + scriptDeclaration, Opcodes.ACC_PUBLIC, jvmSignature.getAsmMethod().getName(), jvmSignature.getAsmMethod().getDescriptor(), null, null); mv.visitCode(); @@ -85,8 +92,23 @@ public class ScriptCodegen { instructionAdapter.invokespecial(JdkNames.JL_OBJECT.getInternalName(), "", "()V"); instructionAdapter.load(0, Type.getObjectType("Script")); - StackValue stackValue = new ExpressionCodegen(mv, new FrameMap(), Type.VOID_TYPE, context, state).gen(scriptDeclaration.getBlockExpression()); + + CodegenContext context = outerContext.intoScript(scriptDescriptor); + + FrameMap frameMap = context.prepareFrame(jetTypeMapper); + + Type[] argTypes = jvmSignature.getAsmMethod().getArgumentTypes(); + int add = 0; + + for (int i = 0; i < scriptDescriptor.getValueParameters().size(); i++) { + ValueParameterDescriptor parameter = scriptDescriptor.getValueParameters().get(i); + frameMap.enter(parameter, argTypes[i+add].getSize()); + } + + + StackValue stackValue = new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, context, state).gen(scriptDeclaration.getBlockExpression()); if (stackValue.type != Type.VOID_TYPE) { + stackValue.put(stackValue.type, instructionAdapter); instructionAdapter.putfield("Script", LAST_EXPRESSION_VALUE_FIELD_NAME, blockType.getDescriptor()); } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java index e78282eae79..cf158292b9e 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java @@ -36,6 +36,7 @@ import org.jetbrains.jet.utils.PathUtil; import java.io.File; import java.io.PrintStream; +import java.util.Collections; import java.util.List; import static org.jetbrains.jet.cli.common.ExitCode.*; @@ -84,8 +85,8 @@ public class K2JVMCompiler extends CLICompiler scriptArgs = arguments.script ? arguments.freeArgs.subList(1, arguments.freeArgs.size()) : Collections.emptyList(); + K2JVMCompileEnvironmentConfiguration configuration = new K2JVMCompileEnvironmentConfiguration(environment, messageCollector, arguments.script, scriptArgs); messageCollector.report(CompilerMessageSeverity.LOGGING, "Configuring the compilation environment", CompilerMessageLocation.NO_LOCATION); @@ -115,7 +116,12 @@ public class K2JVMCompiler extends CLICompiler"); + + public static List scriptParameters() { + AnalyzerScriptParameter argsParameter = new AnalyzerScriptParameter(ARGS_NAME, ARGS_TYPE); + return Collections.singletonList(argsParameter); + } + +} diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java index 8c124fa9e2a..852babf8b84 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java @@ -45,6 +45,7 @@ import java.net.MalformedURLException; import java.net.URL; import java.net.URLClassLoader; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.jar.*; @@ -143,7 +144,7 @@ public class CompileEnvironmentUtil { scriptEnvironment.addSources(moduleScriptFile); GenerationState generationState = KotlinToJVMBytecodeCompiler - .analyzeAndGenerate(new K2JVMCompileEnvironmentConfiguration(scriptEnvironment, messageCollector), false); + .analyzeAndGenerate(new K2JVMCompileEnvironmentConfiguration(scriptEnvironment, messageCollector, false, Collections.emptyList()), false); if (generationState == null) { return null; } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/K2JVMCompileEnvironmentConfiguration.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/K2JVMCompileEnvironmentConfiguration.java index 97dc704fd99..22a592528db 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/K2JVMCompileEnvironmentConfiguration.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/K2JVMCompileEnvironmentConfiguration.java @@ -21,11 +21,15 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.cli.common.CompileEnvironmentConfiguration; import org.jetbrains.jet.cli.common.messages.MessageCollector; +import java.util.List; + /** * @author abreslav */ public class K2JVMCompileEnvironmentConfiguration extends CompileEnvironmentConfiguration { private final JetCoreEnvironment environment; + private final boolean script; + private final List scriptArgs; /** * NOTE: It's very important to call dispose for every object of this class or there will be memory leaks. @@ -33,12 +37,22 @@ public class K2JVMCompileEnvironmentConfiguration extends CompileEnvironmentConf * @see Disposer */ public K2JVMCompileEnvironmentConfiguration(@NotNull JetCoreEnvironment environment, - @NotNull MessageCollector messageCollector) { + @NotNull MessageCollector messageCollector, boolean script, List scriptArgs) { super(messageCollector); this.environment = environment; + this.script = script; + this.scriptArgs = scriptArgs; } public JetCoreEnvironment getEnvironment() { return environment; } + + public boolean isScript() { + return script; + } + + public List getScriptArgs() { + return scriptArgs; + } } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index f5077050bb4..b84b1223b34 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -37,6 +37,7 @@ import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.name.Name; @@ -49,6 +50,7 @@ import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.net.URL; import java.net.URLClassLoader; +import java.util.Collections; import java.util.List; /** @@ -159,7 +161,7 @@ public class KotlinToJVMBytecodeCompiler { }, AllModules.class.getClassLoader())); Class scriptClass = classLoader.loadClass("Script"); - scriptClass.newInstance(); + scriptClass.getConstructor(String[].class).newInstance(new Object[]{ configuration.getScriptArgs().toArray(new String[0]) }); } catch (Exception e) { throw new RuntimeException("Failed to evaluate script: " + e, e); } @@ -219,7 +221,7 @@ public class KotlinToJVMBytecodeCompiler { K2JVMCompileEnvironmentConfiguration configuration, boolean stubs ) { - AnalyzeExhaust exhaust = analyze(configuration, stubs); + AnalyzeExhaust exhaust = analyze(configuration, configuration.isScript(), stubs); if (exhaust == null) { return null; @@ -233,18 +235,23 @@ public class KotlinToJVMBytecodeCompiler { @Nullable private static AnalyzeExhaust analyze( final K2JVMCompileEnvironmentConfiguration configuration, - boolean stubs) { + boolean script, boolean stubs) { final JetCoreEnvironment environment = configuration.getEnvironment(); AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport(configuration.getMessageCollector()); final Predicate filesToAnalyzeCompletely = stubs ? Predicates.alwaysFalse() : Predicates.alwaysTrue(); + final List scriptParameters = + script ? CommandLineScriptUtils.scriptParameters() : Collections.emptyList(); analyzerWithCompilerReport.analyzeAndReport( new Function0() { @NotNull @Override public AnalyzeExhaust invoke() { return AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( - environment.getProject(), environment.getSourceFiles(), filesToAnalyzeCompletely, + environment.getProject(), + environment.getSourceFiles(), + scriptParameters, + filesToAnalyzeCompletely, configuration.getEnvironment().getCompilerDependencies()); } }, environment.getSourceFiles() diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index fa918fa82e8..59f2358601a 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinderForJvm; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; @@ -44,8 +45,8 @@ import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptResolver; import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; @@ -71,6 +72,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final CompilerDependencies compilerDependencies; private CompilerSpecialMode compilerSpecialMode; private JavaBridgeConfiguration javaBridgeConfiguration; + private JavaDescriptorResolver javaDescriptorResolver; private PsiClassFinderForJvm psiClassFinderForJvm; private DeclarationResolver declarationResolver; private AnnotationResolver annotationResolver; @@ -85,8 +87,8 @@ public class InjectorForTopDownAnalyzerForJvm { private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; private TypeHierarchyResolver typeHierarchyResolver; + private ScriptResolver scriptResolver; private JavaSemanticServices javaSemanticServices; - private JavaDescriptorResolver javaDescriptorResolver; private JavaTypeTransformer javaTypeTransformer; public InjectorForTopDownAnalyzerForJvm( @@ -109,6 +111,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.compilerDependencies = compilerDependencies; this.compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); this.javaBridgeConfiguration = new JavaBridgeConfiguration(); + this.javaDescriptorResolver = new JavaDescriptorResolver(); this.psiClassFinderForJvm = new PsiClassFinderForJvm(); this.declarationResolver = new DeclarationResolver(); this.annotationResolver = new AnnotationResolver(); @@ -123,8 +126,8 @@ public class InjectorForTopDownAnalyzerForJvm { this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); this.typeHierarchyResolver = new TypeHierarchyResolver(); + this.scriptResolver = new ScriptResolver(); this.javaSemanticServices = new JavaSemanticServices(); - this.javaDescriptorResolver = new JavaDescriptorResolver(); this.javaTypeTransformer = new JavaTypeTransformer(); this.topDownAnalyzer.setBodyResolver(bodyResolver); @@ -133,6 +136,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.topDownAnalyzer.setDeclarationResolver(declarationResolver); this.topDownAnalyzer.setDeclarationsChecker(declarationsChecker); this.topDownAnalyzer.setDelegationResolver(delegationResolver); + this.topDownAnalyzer.setDependencyClassByQualifiedNameResolver(javaDescriptorResolver); this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); this.topDownAnalyzer.setNamespaceFactory(namespaceFactoryImpl); this.topDownAnalyzer.setOverloadResolver(overloadResolver); @@ -146,6 +150,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.bodyResolver.setCallResolver(callResolver); this.bodyResolver.setDescriptorResolver(descriptorResolver); this.bodyResolver.setExpressionTypingServices(expressionTypingServices); + this.bodyResolver.setScriptResolver(scriptResolver); this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); this.bodyResolver.setTrace(observableBindingTrace); @@ -162,6 +167,12 @@ public class InjectorForTopDownAnalyzerForJvm { this.javaBridgeConfiguration.setMode(compilerSpecialMode); this.javaBridgeConfiguration.setProject(project); + javaDescriptorResolver.setNamespaceFactory(namespaceFactoryImpl); + javaDescriptorResolver.setProject(project); + javaDescriptorResolver.setPsiClassFinder(psiClassFinderForJvm); + javaDescriptorResolver.setSemanticServices(javaSemanticServices); + javaDescriptorResolver.setTrace(observableBindingTrace); + psiClassFinderForJvm.setCompilerDependencies(compilerDependencies); psiClassFinderForJvm.setProject(project); @@ -211,19 +222,22 @@ public class InjectorForTopDownAnalyzerForJvm { typeHierarchyResolver.setDescriptorResolver(descriptorResolver); typeHierarchyResolver.setImportsResolver(importsResolver); typeHierarchyResolver.setNamespaceFactory(namespaceFactoryImpl); + typeHierarchyResolver.setScriptResolver(scriptResolver); typeHierarchyResolver.setTrace(observableBindingTrace); + scriptResolver.setContext(topDownAnalysisContext); + scriptResolver.setDependencyClassByQualifiedNameResolver(javaDescriptorResolver); + scriptResolver.setExpressionTypingServices(expressionTypingServices); + scriptResolver.setModuleDescriptor(moduleDescriptor); + scriptResolver.setNamespaceFactory(namespaceFactoryImpl); + scriptResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); + scriptResolver.setTrace(observableBindingTrace); + javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); javaSemanticServices.setPsiClassFinder(psiClassFinderForJvm); javaSemanticServices.setTrace(observableBindingTrace); javaSemanticServices.setTypeTransformer(javaTypeTransformer); - javaDescriptorResolver.setNamespaceFactory(namespaceFactoryImpl); - javaDescriptorResolver.setProject(project); - javaDescriptorResolver.setPsiClassFinder(psiClassFinderForJvm); - javaDescriptorResolver.setSemanticServices(javaSemanticServices); - javaDescriptorResolver.setTrace(observableBindingTrace); - javaTypeTransformer.setJavaSemanticServices(javaSemanticServices); javaTypeTransformer.setResolver(javaDescriptorResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index 5b14ec0e973..e4d15257626 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -27,11 +27,17 @@ import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; +import org.jetbrains.jet.lang.resolve.AnalyzingUtils; +import org.jetbrains.jet.lang.resolve.BindingTraceContext; +import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.Collection; import java.util.Collections; +import java.util.List; import static org.jetbrains.jet.lang.resolve.java.CompilerDependencies.compilerDependenciesForProduction; @@ -49,28 +55,31 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { @NotNull public AnalyzeExhaust analyzeFiles(@NotNull Project project, @NotNull Collection files, + @NotNull List scriptParameters, @NotNull Predicate filesToAnalyzeCompletely) { - return analyzeFilesWithJavaIntegration(project, files, filesToAnalyzeCompletely, + return analyzeFilesWithJavaIntegration(project, files, scriptParameters, filesToAnalyzeCompletely, compilerDependenciesForProduction(CompilerSpecialMode.REGULAR), true); } @NotNull @Override public AnalyzeExhaust analyzeBodiesInFiles(@NotNull Project project, + @NotNull List scriptParameters, @NotNull Predicate filesForBodiesResolve, @NotNull BindingTrace headersTraceContext, @NotNull BodiesResolveContext bodiesResolveContext ) { return analyzeBodiesInFilesWithJavaIntegration( - project, filesForBodiesResolve, compilerDependenciesForProduction(CompilerSpecialMode.REGULAR), + project, scriptParameters, filesForBodiesResolve, + compilerDependenciesForProduction(CompilerSpecialMode.REGULAR), headersTraceContext, bodiesResolveContext); } public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors( - JetFile file, @NotNull CompilerDependencies compilerDependencies) { + JetFile file, List scriptParameters, @NotNull CompilerDependencies compilerDependencies) { AnalyzingUtils.checkForSyntacticErrors(file); - AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file, compilerDependencies); + AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file, scriptParameters, compilerDependencies); AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext()); @@ -78,20 +87,20 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { } public static AnalyzeExhaust analyzeOneFileWithJavaIntegration( - JetFile file, @NotNull CompilerDependencies compilerDependencies) { - return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), + JetFile file, List scriptParameters, @NotNull CompilerDependencies compilerDependencies) { + return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), scriptParameters, Predicates.alwaysTrue(), compilerDependencies); } public static AnalyzeExhaust analyzeFilesWithJavaIntegration( - Project project, Collection files, Predicate filesToAnalyzeCompletely, + Project project, Collection files, List scriptParameters, Predicate filesToAnalyzeCompletely, @NotNull CompilerDependencies compilerDependencies) { return analyzeFilesWithJavaIntegration( - project, files, filesToAnalyzeCompletely, compilerDependencies, false); + project, files, scriptParameters, filesToAnalyzeCompletely, compilerDependencies, false); } public static AnalyzeExhaust analyzeFilesWithJavaIntegration( - Project project, Collection files, Predicate filesToAnalyzeCompletely, + Project project, Collection files, List scriptParameters, Predicate filesToAnalyzeCompletely, @NotNull CompilerDependencies compilerDependencies, boolean storeContextForBodiesResolve) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); @@ -99,13 +108,13 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { final ModuleDescriptor owner = new ModuleDescriptor(Name.special("")); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - filesToAnalyzeCompletely, false, false); + filesToAnalyzeCompletely, false, false, scriptParameters); InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm( project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, compilerDependencies); try { - injector.getTopDownAnalyzer().analyzeFiles(files); + injector.getTopDownAnalyzer().analyzeFiles(files, scriptParameters); BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ? new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) : null; @@ -116,14 +125,14 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { } public static AnalyzeExhaust analyzeBodiesInFilesWithJavaIntegration( - Project project, Predicate filesToAnalyzeCompletely, + Project project, List scriptParameters, Predicate filesToAnalyzeCompletely, @NotNull CompilerDependencies compilerDependencies, @NotNull BindingTrace traceContext, @NotNull BodiesResolveContext bodiesResolveContext) { final ModuleDescriptor owner = new ModuleDescriptor(Name.special("")); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - filesToAnalyzeCompletely, false, false); + filesToAnalyzeCompletely, false, false, scriptParameters); bodiesResolveContext.setTopDownAnalysisParameters(topDownAnalysisParameters); @@ -145,6 +154,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { Project project = files.iterator().next().getProject(); - return analyzeFilesWithJavaIntegration(project, files, Predicates.alwaysFalse(), compilerDependencies); + return analyzeFilesWithJavaIntegration(project, + files, Collections.emptyList(), Predicates.alwaysFalse(), + compilerDependencies); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java index b5fd8f9768a..872a4a5354e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java +++ b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java @@ -21,10 +21,12 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.BodiesResolveContext; import java.util.Collection; +import java.util.List; /** * @author Pavel Talanov @@ -34,10 +36,12 @@ public interface AnalyzerFacade { @NotNull AnalyzeExhaust analyzeFiles(@NotNull Project project, @NotNull Collection files, + @NotNull List scriptParameters, @NotNull Predicate filesToAnalyzeCompletely); @NotNull AnalyzeExhaust analyzeBodiesInFiles(@NotNull Project project, + @NotNull List scriptParameters, @NotNull Predicate filesForBodiesResolve, @NotNull BindingTrace traceContext, @NotNull BodiesResolveContext bodiesResolveContext); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 6dda0b5f2e6..c71cfc5e01d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -41,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptResolver; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; @@ -63,6 +65,7 @@ public class InjectorForTopDownAnalyzerBasic { private final ObservableBindingTrace observableBindingTrace; private final ModuleDescriptor moduleDescriptor; private final ModuleConfiguration moduleConfiguration; + private DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummyImpl; private DeclarationResolver declarationResolver; private AnnotationResolver annotationResolver; private CallResolver callResolver; @@ -76,6 +79,7 @@ public class InjectorForTopDownAnalyzerBasic { private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; private TypeHierarchyResolver typeHierarchyResolver; + private ScriptResolver scriptResolver; public InjectorForTopDownAnalyzerBasic( @NotNull Project project, @@ -95,6 +99,7 @@ public class InjectorForTopDownAnalyzerBasic { this.observableBindingTrace = observableBindingTrace; this.moduleDescriptor = moduleDescriptor; this.moduleConfiguration = moduleConfiguration; + this.dependencyClassByQualifiedNameResolverDummyImpl = new DependencyClassByQualifiedNameResolverDummyImpl(); this.declarationResolver = new DeclarationResolver(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -108,6 +113,7 @@ public class InjectorForTopDownAnalyzerBasic { this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); this.typeHierarchyResolver = new TypeHierarchyResolver(); + this.scriptResolver = new ScriptResolver(); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setContext(topDownAnalysisContext); @@ -115,6 +121,7 @@ public class InjectorForTopDownAnalyzerBasic { this.topDownAnalyzer.setDeclarationResolver(declarationResolver); this.topDownAnalyzer.setDeclarationsChecker(declarationsChecker); this.topDownAnalyzer.setDelegationResolver(delegationResolver); + this.topDownAnalyzer.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummyImpl); this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); this.topDownAnalyzer.setNamespaceFactory(namespaceFactoryImpl); this.topDownAnalyzer.setOverloadResolver(overloadResolver); @@ -128,6 +135,7 @@ public class InjectorForTopDownAnalyzerBasic { this.bodyResolver.setCallResolver(callResolver); this.bodyResolver.setDescriptorResolver(descriptorResolver); this.bodyResolver.setExpressionTypingServices(expressionTypingServices); + this.bodyResolver.setScriptResolver(scriptResolver); this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); this.bodyResolver.setTrace(observableBindingTrace); @@ -186,8 +194,17 @@ public class InjectorForTopDownAnalyzerBasic { typeHierarchyResolver.setDescriptorResolver(descriptorResolver); typeHierarchyResolver.setImportsResolver(importsResolver); typeHierarchyResolver.setNamespaceFactory(namespaceFactoryImpl); + typeHierarchyResolver.setScriptResolver(scriptResolver); typeHierarchyResolver.setTrace(observableBindingTrace); + scriptResolver.setContext(topDownAnalysisContext); + scriptResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummyImpl); + scriptResolver.setExpressionTypingServices(expressionTypingServices); + scriptResolver.setModuleDescriptor(moduleDescriptor); + scriptResolver.setNamespaceFactory(namespaceFactoryImpl); + scriptResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); + scriptResolver.setTrace(observableBindingTrace); + } @PreDestroy diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java index 2b3e96ad16a..15b7abd2419 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java @@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeSubstitutor; import java.util.Collections; +import java.util.List; /** * @author Stepan Koltsov @@ -32,13 +33,15 @@ public class ScriptDescriptor extends DeclarationDescriptorImpl { private static final Name NAME = Name.special("