azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

script parameters

Browse Source 
still a lot of things to do
This commit is contained in:
Stepan Koltsov
2012-05-28 20:30:23 +04:00
parent 6244404344
commit 30e44fdc5f
49 changed files with 833 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files
build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java
+1 -1
View File
@@ -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.<String>emptyList());
if (( stdlib != null ) && ( stdlib.trim().length() > 0 )) {
File file = new File(stdlib);
compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java
+4
View File
@@ -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);
}
compiler/backend/src/org/jetbrains/jet/codegen/CodegenContexts.java
+21
View File
@@ -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);
compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java
+13
View File
@@ -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<JetFile> 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");
}
compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java
+22
View File
@@ -871,6 +871,27 @@ public class JetTypeMapper {
return signatureWriter.makeJvmMethodSignature("<init>");
}
@NotNull
public JvmMethodSignature mapScriptSignature(@NotNull ScriptDescriptor script) {
BothSignatureWriter signatureWriter = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD, false);
writeFormalTypeParameters(Collections.<TypeParameterDescriptor>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("<init>");
}
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)) {
compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java
+25 -3
View File
@@ -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, "<init>", "()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(), "<init>", "()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());
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java
+9 -3
View File
@@ -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<K2JVMCompilerArguments, K2JVMComp
CompilerDependencies dependencies = new CompilerDependencies(mode, CompilerDependencies.findRtJar(), jdkHeadersJar, runtimeJar);
JetCoreEnvironment environment = JetCoreEnvironment.getCoreEnvironmentForJVM(rootDisposable, dependencies);
K2JVMCompileEnvironmentConfiguration configuration =
new K2JVMCompileEnvironmentConfiguration(environment, messageCollector);
List<String> scriptArgs = arguments.script ? arguments.freeArgs.subList(1, arguments.freeArgs.size()) : Collections.<String>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<K2JVMCompilerArguments, K2JVMComp
if (arguments.src != null) {
sources.add(arguments.src);
}
sources.addAll(arguments.freeArgs);
if (arguments.script) {
sources.add(arguments.freeArgs.get(0));
}
else {
sources.addAll(arguments.freeArgs);
}
noErrors = KotlinToJVMBytecodeCompiler.compileBunchOfSources(configuration,
sources, arguments.jar, arguments.outputDir, arguments.script, arguments.includeRuntime);
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CommandLineScriptUtils.java
+40
View File
@@ -0,0 +1,40 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.cli.jvm.compiler;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.ref.JetTypeName;
import java.util.Collections;
import java.util.List;
/**
* @author Stepan Koltsov
*/
public class CommandLineScriptUtils {
private static final Name ARGS_NAME = Name.identifier("args");
private static final JetTypeName ARGS_TYPE = JetTypeName.parse("jet.Array<jet.String>");
public static List<AnalyzerScriptParameter> scriptParameters() {
AnalyzerScriptParameter argsParameter = new AnalyzerScriptParameter(ARGS_NAME, ARGS_TYPE);
return Collections.singletonList(argsParameter);
}
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java
+2 -1
View File
@@ -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.<String>emptyList()), false);
if (generationState == null) {
return null;
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/K2JVMCompileEnvironmentConfiguration.java
+15 -1
View File
@@ -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<String> 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<String> scriptArgs) {
super(messageCollector);
this.environment = environment;
this.script = script;
this.scriptArgs = scriptArgs;
}
public JetCoreEnvironment getEnvironment() {
return environment;
}
public boolean isScript() {
return script;
}
public List<String> getScriptArgs() {
return scriptArgs;
}
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
+11 -4
View File
@@ -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<PsiFile> filesToAnalyzeCompletely =
stubs ? Predicates.<PsiFile>alwaysFalse() : Predicates.<PsiFile>alwaysTrue();
final List<AnalyzerScriptParameter> scriptParameters =
script ? CommandLineScriptUtils.scriptParameters() : Collections.<AnalyzerScriptParameter>emptyList();
analyzerWithCompilerReport.analyzeAndReport(
new Function0<AnalyzeExhaust>() {
@NotNull
@Override
public AnalyzeExhaust invoke() {
return AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
environment.getProject(), environment.getSourceFiles(), filesToAnalyzeCompletely,
environment.getProject(),
environment.getSourceFiles(),
scriptParameters,
filesToAnalyzeCompletely,
configuration.getEnvironment().getCompilerDependencies());
}
}, environment.getSourceFiles()
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java
+23 -9
View File
@@ -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);
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java
+25 -14
View File
@@ -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<JetFile> files,
@NotNull List<AnalyzerScriptParameter> scriptParameters,
@NotNull Predicate<PsiFile> 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<AnalyzerScriptParameter> scriptParameters,
@NotNull Predicate<PsiFile> 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<AnalyzerScriptParameter> 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<AnalyzerScriptParameter> scriptParameters, @NotNull CompilerDependencies compilerDependencies) {
return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), scriptParameters,
Predicates.<PsiFile>alwaysTrue(), compilerDependencies);
}
public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
Project project, Collection<JetFile> files, Predicate<PsiFile> filesToAnalyzeCompletely,
Project project, Collection<JetFile> files, List<AnalyzerScriptParameter> scriptParameters, Predicate<PsiFile> filesToAnalyzeCompletely,
@NotNull CompilerDependencies compilerDependencies) {
return analyzeFilesWithJavaIntegration(
project, files, filesToAnalyzeCompletely, compilerDependencies, false);
project, files, scriptParameters, filesToAnalyzeCompletely, compilerDependencies, false);
}
public static AnalyzeExhaust analyzeFilesWithJavaIntegration(
Project project, Collection<JetFile> files, Predicate<PsiFile> filesToAnalyzeCompletely,
Project project, Collection<JetFile> files, List<AnalyzerScriptParameter> scriptParameters, Predicate<PsiFile> 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("<module>"));
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<PsiFile> filesToAnalyzeCompletely,
Project project, List<AnalyzerScriptParameter> scriptParameters, Predicate<PsiFile> filesToAnalyzeCompletely,
@NotNull CompilerDependencies compilerDependencies,
@NotNull BindingTrace traceContext,
@NotNull BodiesResolveContext bodiesResolveContext) {
final ModuleDescriptor owner = new ModuleDescriptor(Name.special("<module>"));
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.<PsiFile>alwaysFalse(), compilerDependencies);
return analyzeFilesWithJavaIntegration(project,
files, Collections.<AnalyzerScriptParameter>emptyList(), Predicates.<PsiFile>alwaysFalse(),
compilerDependencies);
}
}
compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacade.java
+4
View File
@@ -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<JetFile> files,
@NotNull List<AnalyzerScriptParameter> scriptParameters,
@NotNull Predicate<PsiFile> filesToAnalyzeCompletely);
@NotNull
AnalyzeExhaust analyzeBodiesInFiles(@NotNull Project project,
@NotNull List<AnalyzerScriptParameter> scriptParameters,
@NotNull Predicate<PsiFile> filesForBodiesResolve,
@NotNull BindingTrace traceContext,
@NotNull BodiesResolveContext bodiesResolveContext);
compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java
+17
View File
@@ -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
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java
+9 -1
View File
@@ -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("<script>");
private JetType returnType;
private List<ValueParameterDescriptor> valueParameters;
public ScriptDescriptor(@Nullable DeclarationDescriptor containingDeclaration) {
super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(), NAME);
}
public void initialize(@NotNull JetType returnType) {
public void initialize(@NotNull JetType returnType, @NotNull List<ValueParameterDescriptor> valueParameters) {
this.returnType = returnType;
this.valueParameters = valueParameters;
}
@NotNull
@@ -46,6 +49,11 @@ public class ScriptDescriptor extends DeclarationDescriptorImpl {
return returnType;
}
@NotNull
public List<ValueParameterDescriptor> getValueParameters() {
return valueParameters;
}
@Override
public DeclarationDescriptor substitute(TypeSubstitutor substitutor) {
throw new IllegalStateException("nothing to substitute in script");
compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzerScriptParameter.java
+46
View File
@@ -0,0 +1,46 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.ref.JetTypeName;
/**
* @author Stepan Koltsov
*/
public class AnalyzerScriptParameter {
@NotNull
private final Name name;
@NotNull
private final JetTypeName type;
public AnalyzerScriptParameter(@NotNull Name name, @NotNull JetTypeName type) {
this.name = name;
this.type = type;
}
@NotNull
public Name getName() {
return name;
}
@NotNull
public JetTypeName getType() {
return type;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
+70 -28
View File
@@ -21,8 +21,41 @@ import com.google.common.collect.Sets;
import com.intellij.psi.PsiElement;
import com.intellij.util.containers.Queue;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassKind;
import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptorUtil;
import org.jetbrains.jet.lang.descriptors.MutableClassDescriptor;
import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
import org.jetbrains.jet.lang.descriptors.PropertyGetterDescriptor;
import org.jetbrains.jet.lang.descriptors.PropertySetterDescriptor;
import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
import org.jetbrains.jet.lang.psi.JetClass;
import org.jetbrains.jet.lang.psi.JetClassInitializer;
import org.jetbrains.jet.lang.psi.JetClassOrObject;
import org.jetbrains.jet.lang.psi.JetDeclarationWithBody;
import org.jetbrains.jet.lang.psi.JetDelegationSpecifier;
import org.jetbrains.jet.lang.psi.JetDelegatorByExpressionSpecifier;
import org.jetbrains.jet.lang.psi.JetDelegatorToSuperCall;
import org.jetbrains.jet.lang.psi.JetDelegatorToSuperClass;
import org.jetbrains.jet.lang.psi.JetDelegatorToThisCall;
import org.jetbrains.jet.lang.psi.JetElement;
import org.jetbrains.jet.lang.psi.JetEnumEntry;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.psi.JetNamedFunction;
import org.jetbrains.jet.lang.psi.JetObjectDeclaration;
import org.jetbrains.jet.lang.psi.JetParameter;
import org.jetbrains.jet.lang.psi.JetProperty;
import org.jetbrains.jet.lang.psi.JetPropertyAccessor;
import org.jetbrains.jet.lang.psi.JetReferenceExpression;
import org.jetbrains.jet.lang.psi.JetSecondaryConstructor;
import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
import org.jetbrains.jet.lang.psi.JetTypeReference;
import org.jetbrains.jet.lang.psi.JetValueArgumentList;
import org.jetbrains.jet.lang.psi.JetVisitorVoid;
import org.jetbrains.jet.lang.resolve.calls.CallMaker;
import org.jetbrains.jet.lang.resolve.calls.CallResolver;
import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults;
@@ -31,12 +64,13 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.types.DeferredType;
import org.jetbrains.jet.lang.types.ErrorUtils;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeConstructor;
import org.jetbrains.jet.lang.types.TypeUtils;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lang.types.expressions.CoercionStrategy;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
import org.jetbrains.jet.lang.types.expressions.LabelResolver;
import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
import org.jetbrains.jet.lexer.JetTokens;
import org.jetbrains.jet.util.Box;
@@ -44,9 +78,29 @@ import org.jetbrains.jet.util.lazy.ReenteringLazyValueComputationException;
import org.jetbrains.jet.util.slicedmap.WritableSlice;
import javax.inject.Inject;
import java.util.*;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.jetbrains.jet.lang.diagnostics.Errors.*;
import static org.jetbrains.jet.lang.diagnostics.Errors.ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR;
import static org.jetbrains.jet.lang.diagnostics.Errors.BY_IN_SECONDARY_CONSTRUCTOR;
import static org.jetbrains.jet.lang.diagnostics.Errors.CONSTRUCTOR_IN_TRAIT;
import static org.jetbrains.jet.lang.diagnostics.Errors.DELEGATION_IN_TRAIT;
import static org.jetbrains.jet.lang.diagnostics.Errors.DELEGATION_NOT_TO_TRAIT;
import static org.jetbrains.jet.lang.diagnostics.Errors.FINAL_SUPERTYPE;
import static org.jetbrains.jet.lang.diagnostics.Errors.INITIALIZER_WITH_NO_ARGUMENTS;
import static org.jetbrains.jet.lang.diagnostics.Errors.MANY_CALLS_TO_THIS;
import static org.jetbrains.jet.lang.diagnostics.Errors.MANY_CLASSES_IN_SUPERTYPE_LIST;
import static org.jetbrains.jet.lang.diagnostics.Errors.SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY;
import static org.jetbrains.jet.lang.diagnostics.Errors.SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST;
import static org.jetbrains.jet.lang.diagnostics.Errors.SUPERTYPE_APPEARS_TWICE;
import static org.jetbrains.jet.lang.diagnostics.Errors.SUPERTYPE_INITIALIZED_IN_TRAIT;
import static org.jetbrains.jet.lang.diagnostics.Errors.SUPERTYPE_NOT_A_CLASS_OR_TRAIT;
import static org.jetbrains.jet.lang.diagnostics.Errors.SUPERTYPE_NOT_INITIALIZED;
import static org.jetbrains.jet.lang.diagnostics.Errors.SUPERTYPE_NOT_INITIALIZED_DEFAULT;
import static org.jetbrains.jet.lang.diagnostics.Errors.TYPE_MISMATCH;
import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE;
import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
@@ -61,6 +115,8 @@ public class BodyResolver {
@NotNull
private DescriptorResolver descriptorResolver;
@NotNull
private ScriptResolver scriptResolver;
@NotNull
private ExpressionTypingServices expressionTypingServices;
@NotNull
private CallResolver callResolver;
@@ -77,6 +133,11 @@ public class BodyResolver {
this.descriptorResolver = descriptorResolver;
}
@Inject
public void setScriptResolver(@NotNull ScriptResolver scriptResolver) {
this.scriptResolver = scriptResolver;
}
@Inject
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
this.expressionTypingServices = expressionTypingServices;
@@ -106,7 +167,7 @@ public class BodyResolver {
resolveSecondaryConstructorBodies();
resolveFunctionBodies();
resolveScripts();
scriptResolver.resolveScripts();
if (!topDownAnalysisParameters.isDeclaredLocally()) {
computeDeferredTypes();
@@ -613,23 +674,4 @@ public class BodyResolver {
}
}
private void resolveScripts() {
for (Map.Entry<JetScript, ScriptDescriptor> e : context.getScripts().entrySet()) {
JetScript declaration = e.getKey();
ScriptDescriptor descriptor = e.getValue();
JetScope scope = context.getScriptScopes().get(declaration);
ExpressionTypingContext context = ExpressionTypingContext.newContext(
expressionTypingServices,
Maps.<JetPattern, DataFlowInfo>newHashMap(),
Maps.<JetPattern, List<VariableDescriptor>>newHashMap(),
new LabelResolver(),
trace,
scope,
DataFlowInfo.EMPTY,
NO_EXPECTED_TYPE,
false);
JetType returnType = expressionTypingServices.getBlockReturnedType(scope, declaration.getBlockExpression(), CoercionStrategy.NO_COERCION, context, trace);
descriptor.initialize(returnType);
}
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptResolver.java
+195
View File
@@ -0,0 +1,195 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.LocalVariableDescriptor;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.psi.JetPattern;
import org.jetbrains.jet.lang.psi.JetScript;
import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
import org.jetbrains.jet.lang.types.ErrorUtils;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeUtils;
import org.jetbrains.jet.lang.types.expressions.CoercionStrategy;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
import org.jetbrains.jet.lang.types.expressions.LabelResolver;
import org.jetbrains.jet.lang.types.ref.JetTypeName;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
/**
* @author Stepan Koltsov
*/
public class ScriptResolver {
@NotNull
private NamespaceFactory namespaceFactory;
@NotNull
private DependencyClassByQualifiedNameResolver dependencyClassByQualifiedNameResolver;
@NotNull
private ModuleDescriptor moduleDescriptor;
@NotNull
private TopDownAnalysisContext context;
@NotNull
private ExpressionTypingServices expressionTypingServices;
@NotNull
private ObservableBindingTrace trace;
@NotNull
private TopDownAnalysisParameters topDownAnalysisParameters;
@Inject
public void setNamespaceFactory(@NotNull NamespaceFactory namespaceFactory) {
this.namespaceFactory = namespaceFactory;
}
@Inject
public void setDependencyClassByQualifiedNameResolver(@NotNull DependencyClassByQualifiedNameResolver dependencyClassByQualifiedNameResolver) {
this.dependencyClassByQualifiedNameResolver = dependencyClassByQualifiedNameResolver;
}
@Inject
public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) {
this.moduleDescriptor = moduleDescriptor;
}
@Inject
public void setContext(@NotNull TopDownAnalysisContext context) {
this.context = context;
}
@Inject
public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
this.expressionTypingServices = expressionTypingServices;
}
@Inject
public void setTrace(@NotNull ObservableBindingTrace trace) {
this.trace = trace;
}
@Inject
public void setTopDownAnalysisParameters(@NotNull TopDownAnalysisParameters topDownAnalysisParameters) {
this.topDownAnalysisParameters = topDownAnalysisParameters;
}
@NotNull
private ClassDescriptor resolveClass(@NotNull FqName className) {
ClassDescriptor classDescriptor = dependencyClassByQualifiedNameResolver.resolveClass(className);
if (classDescriptor == null) {
throw new IllegalStateException("dependency class not found by name: " + className);
}
return classDescriptor;
}
@NotNull
public JetType resolveTypeName(@NotNull JetTypeName typeName) {
List<JetType> typeArguments = new ArrayList<JetType>();
for (JetTypeName typeArgumentName : typeName.getArguments()) {
typeArguments.add(resolveTypeName(typeArgumentName));
}
ClassDescriptor classDescriptor = resolveClass(typeName.getClassName());
return TypeUtils.substituteParameters(classDescriptor, typeArguments);
}
@NotNull
private ValueParameterDescriptor resolveScriptParameter(
@NotNull AnalyzerScriptParameter scriptParameter,
int index,
@NotNull ScriptDescriptor script) {
JetType type = resolveTypeName(scriptParameter.getType());
return new ValueParameterDescriptorImpl(script, index, Collections.<AnnotationDescriptor>emptyList(), scriptParameter.getName(), false, type, false, null);
}
public void processScriptHierarchy(@NotNull JetScript script, @NotNull JetScope outerScope) {
NamespaceDescriptorImpl ns = namespaceFactory.createNamespaceDescriptorPathIfNeeded(FqName.ROOT);
ScriptDescriptor scriptDescriptor = new ScriptDescriptor(ns);
//WriteThroughScope scriptScope = new WriteThroughScope(
// outerScope, ns.getMemberScope(), new TraceBasedRedeclarationHandler(trace));
WritableScopeImpl scriptScope = new WritableScopeImpl(outerScope, scriptDescriptor, RedeclarationHandler.DO_NOTHING);
scriptScope.changeLockLevel(WritableScope.LockLevel.BOTH);
context.getScriptScopes().put(script, scriptScope);
context.getScripts().put(script, scriptDescriptor);
trace.record(BindingContext.SCRIPT, script, scriptDescriptor);
}
public void resolveScripts() {
for (Map.Entry<JetScript, ScriptDescriptor> e : context.getScripts().entrySet()) {
JetScript declaration = e.getKey();
ScriptDescriptor descriptor = e.getValue();
WritableScope scope = context.getScriptScopes().get(declaration);
List<ValueParameterDescriptor> valueParameters = Lists.newArrayList();
int index = 0;
for (AnalyzerScriptParameter scriptParameter : topDownAnalysisParameters.getScriptParameters()) {
ValueParameterDescriptor parameter = resolveScriptParameter(scriptParameter, index, descriptor);
valueParameters.add(parameter);
scope.addVariableDescriptor(parameter);
++index;
}
scope.changeLockLevel(WritableScope.LockLevel.READING);
ExpressionTypingContext context = ExpressionTypingContext.newContext(
expressionTypingServices,
Maps.<JetPattern, DataFlowInfo>newHashMap(),
Maps.<JetPattern, List<VariableDescriptor>>newHashMap(),
new LabelResolver(),
trace,
scope,
DataFlowInfo.EMPTY,
NO_EXPECTED_TYPE,
false);
JetType returnType = expressionTypingServices.getBlockReturnedType(scope, declaration.getBlockExpression(), CoercionStrategy.NO_COERCION, context, trace);
if (returnType == null) {
returnType = ErrorUtils.createErrorType("getBlockReturnedType returned null");
}
descriptor.initialize(returnType, valueParameters);
}
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java
+12 -1
View File
@@ -20,6 +20,8 @@ import com.google.common.base.Predicate;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
import java.util.List;
/**
* Various junk that cannot be placed into context (yet).
*
@@ -30,14 +32,18 @@ public class TopDownAnalysisParameters {
private final Predicate<PsiFile> analyzeCompletely;
private final boolean analyzingBootstrapLibrary;
private final boolean declaredLocally;
@NotNull
private final List<AnalyzerScriptParameter> scriptParameters;
public TopDownAnalysisParameters(
@NotNull Predicate<PsiFile> analyzeCompletely,
boolean analyzingBootstrapLibrary,
boolean declaredLocally) {
boolean declaredLocally,
@NotNull List<AnalyzerScriptParameter> scriptParameters) {
this.analyzeCompletely = analyzeCompletely;
this.analyzingBootstrapLibrary = analyzingBootstrapLibrary;
this.declaredLocally = declaredLocally;
this.scriptParameters = scriptParameters;
}
@NotNull
@@ -52,4 +58,9 @@ public class TopDownAnalysisParameters {
public boolean isDeclaredLocally() {
return declaredLocally;
}
@NotNull
public List<AnalyzerScriptParameter> getScriptParameters() {
return scriptParameters;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
+21 -4
View File
@@ -24,6 +24,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerBasic;
import org.jetbrains.jet.lang.ModuleConfiguration;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.psi.JetDeclaration;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetObjectDeclaration;
@@ -32,7 +33,11 @@ import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeUtils;
import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
import org.jetbrains.jet.lang.types.ref.JetTypeName;
import javax.inject.Inject;
import java.util.ArrayList;
@@ -65,6 +70,8 @@ public class TopDownAnalyzer {
private ModuleDescriptor moduleDescriptor;
@NotNull
private NamespaceFactoryImpl namespaceFactory;
@NotNull
private DependencyClassByQualifiedNameResolver dependencyClassByQualifiedNameResolver;
private BodyResolver bodyResolver;
private ControlFlowAnalyzer controlFlowAnalyzer;
@@ -135,6 +142,12 @@ public class TopDownAnalyzer {
this.declarationsChecker = declarationsChecker;
}
@Inject
public void setDependencyClassByQualifiedNameResolver(@NotNull DependencyClassByQualifiedNameResolver dependencyClassByQualifiedNameResolver) {
this.dependencyClassByQualifiedNameResolver = dependencyClassByQualifiedNameResolver;
}
public void doProcess(
JetScope outerScope,
NamespaceLikeBuilder owner,
@@ -184,7 +197,8 @@ public class TopDownAnalyzer {
@NotNull NamespaceDescriptorImpl standardLibraryNamespace,
@NotNull List<JetFile> files) {
TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(Predicates.<PsiFile>alwaysFalse(), true, false);
TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
Predicates.<PsiFile>alwaysFalse(), true, false, Collections.<AnalyzerScriptParameter>emptyList());
InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
project, topDownAnalysisParameters, new ObservableBindingTrace(trace),
JetStandardClasses.FAKE_STANDARD_CLASSES_MODULE, ModuleConfiguration.EMPTY);
@@ -215,7 +229,8 @@ public class TopDownAnalyzer {
ModuleDescriptor moduleDescriptor = new ModuleDescriptor(Name.special("<dummy for object>"));
TopDownAnalysisParameters topDownAnalysisParameters =
new TopDownAnalysisParameters(Predicates.equalTo(object.getContainingFile()), false, true);
new TopDownAnalysisParameters(Predicates.equalTo(object.getContainingFile()),
false, true, Collections.<AnalyzerScriptParameter>emptyList());
InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
project, topDownAnalysisParameters, new ObservableBindingTrace(trace), moduleDescriptor,
@@ -256,11 +271,13 @@ public class TopDownAnalyzer {
}, Collections.<PsiElement>singletonList(object));
}
public void analyzeFiles(Collection<JetFile> files) {
public void analyzeFiles(
@NotNull Collection<JetFile> files,
@NotNull List<AnalyzerScriptParameter> scriptParameters) {
final WritableScope scope = new WritableScopeImpl(
JetScope.EMPTY, moduleDescriptor,
new TraceBasedRedeclarationHandler(trace)).setDebugName("Root scope in analyzeNamespace");
scope.changeLockLevel(WritableScope.LockLevel.BOTH);
NamespaceDescriptorImpl rootNs = namespaceFactory.createNamespaceDescriptorPathIfNeeded(FqName.ROOT);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
+8 -13
View File
@@ -57,6 +57,8 @@ public class TypeHierarchyResolver {
@NotNull
private DescriptorResolver descriptorResolver;
@NotNull
private ScriptResolver scriptResolver;
@NotNull
private NamespaceFactoryImpl namespaceFactory;
@NotNull
private BindingTrace trace;
@@ -79,6 +81,11 @@ public class TypeHierarchyResolver {
this.descriptorResolver = descriptorResolver;
}
@Inject
public void setScriptResolver(@NotNull ScriptResolver scriptResolver) {
this.scriptResolver = scriptResolver;
}
@Inject
public void setNamespaceFactory(@NotNull NamespaceFactoryImpl namespaceFactory) {
this.namespaceFactory = namespaceFactory;
@@ -192,7 +199,7 @@ public class TypeHierarchyResolver {
public void visitJetFile(JetFile file) {
if (file.isScript()) {
JetScript script = file.getScript();
processScript(script);
scriptResolver.processScriptHierarchy(script, outerScope);
return;
}
@@ -208,18 +215,6 @@ public class TypeHierarchyResolver {
prepareForDeferredCall(namespaceScope, namespaceDescriptor, file);
}
private void processScript(JetScript script) {
NamespaceDescriptorImpl ns = namespaceFactory.createNamespaceDescriptorPathIfNeeded(FqName.ROOT);
ScriptDescriptor scriptDescriptor = new ScriptDescriptor(ns);
//WriteThroughScope scriptScope = new WriteThroughScope(
// outerScope, ns.getMemberScope(), new TraceBasedRedeclarationHandler(trace));
WritableScopeImpl scriptScope = new WritableScopeImpl(outerScope, scriptDescriptor, RedeclarationHandler.DO_NOTHING);
scriptScope.changeLockLevel(WritableScope.LockLevel.BOTH);
context.getScriptScopes().put(script, scriptScope);
context.getScripts().put(script, scriptDescriptor);
trace.record(BindingContext.SCRIPT, script, scriptDescriptor);
}
@Override
public void visitClass(JetClass klass) {
MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor(
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java
+1
View File
@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
import org.jetbrains.jet.lang.types.ref.JetTypeName;
import org.jetbrains.jet.util.lazy.LazyValue;
import javax.inject.Inject;
compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java
+19
View File
@@ -400,6 +400,25 @@ public class TypeUtils {
return null;
}
@NotNull
public static JetType substituteParameters(@NotNull ClassDescriptor clazz, @NotNull List<JetType> actualTypeParameters) {
List<TypeParameterDescriptor> clazzTypeParameters = clazz.getTypeConstructor().getParameters();
if (clazzTypeParameters.size() != actualTypeParameters.size()) {
throw new IllegalArgumentException("type parameter counts do not match: " + clazz + ", " + actualTypeParameters);
}
Map<TypeConstructor, TypeProjection> substitutions = Maps.newHashMap();
for (int i = 0; i < clazzTypeParameters.size(); ++i) {
TypeConstructor typeConstructor = clazzTypeParameters.get(i).getTypeConstructor();
TypeProjection typeProjection = new TypeProjection(actualTypeParameters.get(i));
substitutions.put(typeConstructor, typeProjection);
}
return TypeSubstitutor.create(substitutions).substitute(clazz.getDefaultType(), Variance.INVARIANT);
}
private static void addAllClassDescriptors(@NotNull JetType type, @NotNull Set<ClassDescriptor> set) {
ClassDescriptor cd = getClassDescriptor(type);
if (cd != null) {
compiler/integration-tests/data/script/hello.ktscript
+3 -1
View File
@@ -1 +1,3 @@
println("hello world")
for (arg in args) {
println(arg)
}
compiler/integration-tests/data/script/script.expected
+2 -1
View File
@@ -1,2 +1,3 @@
OUT hello world
OUT hi
OUT there
Return code: 0
compiler/integration-tests/src/org/jetbrains/kotlin/CompilerSmokeTest.java
+1 -1
View File
@@ -53,6 +53,6 @@ public class CompilerSmokeTest extends KotlinIntegrationTestBase {
@Test
public void script() throws Exception {
runCompiler("script", "-script", "hello.ktscript");
runCompiler("script", "-script", "hello.ktscript", "hi", "there");
}
}
compiler/testData/codegen/script/parameter.ktscript
+5
View File
@@ -0,0 +1,5 @@
// expected: sky color is blue
// param: what: jet.String: sky
// param: color: jet.String: blue
"$what color is $color"
compiler/testData/codegen/script/parameterArray.ktscript
+4
View File
@@ -0,0 +1,4 @@
// param: args: jet.Array<jet.String>: three little words
// expected: little
args[1]
compiler/testData/codegen/script/parameterLong.ktscript
+5
View File
@@ -0,0 +1,5 @@
// expected: 19
// param: aa: jet.Long: 17
// param: bb: jet.Int: 2
aa + bb
compiler/tests/org/jetbrains/jet/JetTestUtils.java
+2 -1
View File
@@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic;
import org.jetbrains.jet.lang.diagnostics.Severity;
import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -170,7 +171,7 @@ public class JetTestUtils {
}
public static AnalyzeExhaust analyzeFile(@NotNull JetFile namespace) {
return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace,
return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace, Collections.<AnalyzerScriptParameter>emptyList(),
CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true));
}
compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java
+3 -1
View File
@@ -23,6 +23,7 @@ import org.jetbrains.jet.CompileCompilerDependenciesTest;
import org.jetbrains.jet.JetLiteFixture;
import org.jetbrains.jet.lang.diagnostics.Diagnostic;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
@@ -106,7 +107,8 @@ public class CheckerTestUtilTest extends JetLiteFixture {
public void test(final @NotNull PsiFile psiFile) {
BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
(JetFile) psiFile, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true))
(JetFile) psiFile, Collections.<AnalyzerScriptParameter>emptyList(),
CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true))
.getBindingContext();
String expectedText = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, psiFile)).toString();
compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java
+6 -1
View File
@@ -31,6 +31,7 @@ import org.jetbrains.jet.JetTestCaseBuilder;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -38,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
import java.io.File;
import java.nio.charset.Charset;
import java.util.Collections;
import java.util.List;
/**
@@ -171,7 +173,10 @@ public class JetDiagnosticsTest extends JetLiteFixture {
}
BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
getProject(), jetFiles, Predicates.<PsiFile>alwaysTrue(), myEnvironment.getCompilerDependencies()).getBindingContext();
getProject(), jetFiles, Collections.<AnalyzerScriptParameter>emptyList(),
Predicates.<PsiFile>alwaysTrue(),
myEnvironment.getCompilerDependencies())
.getBindingContext();
boolean ok = true;
compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadJavaBinaryClassTest.java
+3 -1
View File
@@ -28,6 +28,7 @@ import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -86,7 +87,8 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir {
JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
psiFile, jetCoreEnvironment.getCompilerDependencies())
psiFile, Collections.<AnalyzerScriptParameter>emptyList(),
jetCoreEnvironment.getCompilerDependencies())
.getBindingContext();
return bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.topLevel(Name.identifier("test")));
}
compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
+61 -5
View File
@@ -26,13 +26,19 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetPsiUtil;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.ref.JetTypeName;
import org.jetbrains.jet.parsing.JetParsingTest;
import org.objectweb.asm.Type;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
@@ -143,15 +149,56 @@ public abstract class CodegenTestCase extends UsefulTestCase {
assertEquals(myFile.getExpectedValue(), actual);
}
@NotNull
private Class<?> loadClassFromType(@NotNull Type type) {
try {
switch (type.getSort()) {
case Type.OBJECT:
return Class.forName(type.getClassName());
case Type.INT:
return int.class;
case Type.LONG:
return long.class;
default:
// AFAIK there is no way to create array class from class
if (type.getDescriptor().equals("[Ljava/lang/String;")) {
return String[].class;
}
throw new IllegalStateException("not implemented: " + type.getDescriptor());
}
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
private Constructor getConstructor(@NotNull Class<?> clazz, org.objectweb.asm.commons.Method method) {
if (!method.getName().equals("<init>")) {
throw new IllegalArgumentException("not constructor: " + method);
}
Class[] classes = new Class[method.getArgumentTypes().length];
for (int i = 0; i < classes.length; ++i) {
classes[i] = loadClassFromType(method.getArgumentTypes()[i]);
}
try {
return clazz.getConstructor(classes);
}
catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
}
@NotNull
protected String blackBox() throws Exception {
ClassFileFactory codegens = generateClassesInFile();
GeneratedClassLoader loader = createClassLoader(codegens);
GenerationState state = generateClassesInFileGetState();
GeneratedClassLoader loader = createClassLoader(state.getFactory());
try {
if (myFile.getPsiFile().isScript()) {
Class<?> scriptClass = loader.loadClass("Script");
Object scriptInstance = scriptClass.newInstance();
Constructor constructor = getConstructor(scriptClass, state.getScriptConstructorMethod());
Object scriptInstance = constructor.newInstance(myFile.getScriptParameterValues().toArray());
Field field = scriptClass.getDeclaredField("rv");
field.setAccessible(true);
Object result = field.get(scriptInstance);
@@ -183,7 +230,8 @@ public abstract class CodegenTestCase extends UsefulTestCase {
private GenerationState generateCommon(ClassBuilderFactory classBuilderFactory) {
final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
myFile.getPsiFile(), myEnvironment.getCompilerDependencies());
myFile.getPsiFile(), myFile.getScriptParameterTypes(),
myEnvironment.getCompilerDependencies());
analyzeExhaust.throwIfError();
AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
GenerationState state = new GenerationState(myEnvironment.getProject(), classBuilderFactory, analyzeExhaust, Collections.singletonList(myFile.getPsiFile()));
@@ -226,14 +274,22 @@ public abstract class CodegenTestCase extends UsefulTestCase {
@NotNull
protected ClassFileFactory generateClassesInFile() {
GenerationState generationState = generateClassesInFileGetState();
return generationState.getFactory();
}
@NotNull
private GenerationState generateClassesInFileGetState() {
GenerationState generationState;
try {
ClassBuilderFactory classBuilderFactory = ClassBuilderFactories.binaries(false);
return generateCommon(classBuilderFactory).getFactory();
generationState = generateCommon(classBuilderFactory);
} catch (RuntimeException e) {
System.out.println(generateToText());
throw e;
}
return generationState;
}
protected Method generateFunction() {
compiler/tests/org/jetbrains/jet/codegen/CodegenTestFile.java
+64 -4
View File
@@ -16,11 +16,17 @@
package org.jetbrains.jet.codegen;
import com.google.common.collect.Lists;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.ref.JetTypeName;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -33,10 +39,20 @@ public class CodegenTestFile {
private final JetFile psiFile;
@NotNull
private final String expectedValue;
@NotNull
private final List<AnalyzerScriptParameter> scriptParameterTypes;
@NotNull
private final List<Object> scriptParameterValues;
private CodegenTestFile(@NotNull JetFile psiFile, @NotNull String expectedValue) {
private CodegenTestFile(
@NotNull JetFile psiFile,
@NotNull String expectedValue,
@NotNull List<AnalyzerScriptParameter> scriptParameterTypes,
@NotNull List<Object> scriptParameterValues) {
this.psiFile = psiFile;
this.expectedValue = expectedValue;
this.scriptParameterTypes = scriptParameterTypes;
this.scriptParameterValues = scriptParameterValues;
}
@NotNull
@@ -50,12 +66,56 @@ public class CodegenTestFile {
}
@NotNull
public static CodegenTestFile create(@NotNull String name, @NotNull String content, @NotNull Project project) {
JetFile file = (JetFile) JetTestUtils.createFile(name, content, project);
public List<AnalyzerScriptParameter> getScriptParameterTypes() {
return scriptParameterTypes;
}
@NotNull
public List<Object> getScriptParameterValues() {
return scriptParameterValues;
}
@NotNull
public static CodegenTestFile create(@NotNull String fileName, @NotNull String content, @NotNull Project project) {
JetFile file = (JetFile) JetTestUtils.createFile(fileName, content, project);
Matcher matcher = Pattern.compile("// expected: (.*)").matcher(content);
String expectedValue = matcher.find() ? matcher.group(1) : "OK";
return new CodegenTestFile(file, expectedValue);
List<AnalyzerScriptParameter> scriptParameterTypes = Lists.newArrayList();
List<Object> scriptParameterValues = Lists.newArrayList();
if (file.isScript()) {
Pattern scriptParametersPattern = Pattern.compile("param: (\\S+): (\\S+): (\\S.*)");
Matcher scriptParametersMatcher = scriptParametersPattern.matcher(file.getText());
while (scriptParametersMatcher.find()) {
String name = scriptParametersMatcher.group(1);
String type = scriptParametersMatcher.group(2);
String valueString = scriptParametersMatcher.group(3);
Object value;
if (type.equals("jet.String")) {
value = valueString;
}
else if (type.equals("jet.Long")) {
value = Long.parseLong(valueString);
}
else if (type.equals("jet.Int")) {
value = Integer.parseInt(valueString);
}
else if (type.equals("jet.Array<jet.String>")) {
value = valueString.split(" ");
}
else {
throw new AssertionError("TODO");
}
scriptParameterTypes.add(new AnalyzerScriptParameter(Name.identifier(name), JetTypeName.parse(type)));
scriptParameterValues.add(value);
}
}
return new CodegenTestFile(file, expectedValue, scriptParameterTypes, scriptParameterValues);
}
}
compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java
+2 -1
View File
@@ -22,13 +22,14 @@ import org.jetbrains.jet.cli.common.messages.MessageCollector;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
public class CompileTextTest extends CodegenTestCase {
public void testMe() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
createEnvironmentWithMockJdkAndIdeaAnnotations();
String text = "import org.jetbrains.jet.codegen.CompileTextTest; fun x() = CompileTextTest()";
K2JVMCompileEnvironmentConfiguration configuration = new K2JVMCompileEnvironmentConfiguration(
myEnvironment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR);
myEnvironment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR, false, Collections.<String>emptyList());
configuration.getEnvironment().addToClasspathFromClassLoader(getClass().getClassLoader());
ClassLoader classLoader = KotlinToJVMBytecodeCompiler.compileText(configuration, text);
Class<?> namespace = classLoader.loadClass("namespace");
compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java
+3 -1
View File
@@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.CompileCompilerDependenciesTest;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
@@ -36,7 +37,8 @@ public class GenerationUtils {
public static GenerationState compileFileGetGenerationStateForTest(JetFile psiFile, @NotNull CompilerSpecialMode compilerSpecialMode) {
final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
psiFile, CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode, true));
psiFile, Collections.<AnalyzerScriptParameter>emptyList(),
CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode, true));
analyzeExhaust.throwIfError();
GenerationState state = new GenerationState(psiFile.getProject(), ClassBuilderFactories.binaries(false), analyzeExhaust, Collections.singletonList(psiFile));
state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
compiler/tests/org/jetbrains/jet/codegen/ScriptGenTest.java
+12
View File
@@ -42,4 +42,16 @@ public class ScriptGenTest extends CodegenTestCase {
// TODO: check function is visible as instance field (it is currently not)
}
public void testScriptParameter() {
blackBoxFile("script/parameter.ktscript");
}
public void testScriptParameterLong() {
blackBoxFile("script/parameterLong.ktscript");
}
public void testScriptParameterArray() {
blackBoxFile("script/parameterArray.ktscript");
}
}
compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java
+2 -1
View File
@@ -39,6 +39,7 @@ import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Collections;
import java.util.Set;
/**
@@ -87,7 +88,7 @@ public class TestlibTest extends CodegenTestCase {
myEnvironment.addSources(localFileSystem.findFileByPath(JetParsingTest.getTestDataDir() + "/../../libraries/kunit/src"));
GenerationState generationState = KotlinToJVMBytecodeCompiler
.analyzeAndGenerate(new K2JVMCompileEnvironmentConfiguration(myEnvironment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR), false);
.analyzeAndGenerate(new K2JVMCompileEnvironmentConfiguration(myEnvironment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR, false, Collections.<String>emptyList()), false);
if (generationState == null) {
throw new RuntimeException("There were compilation errors");
compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java
+4 -1
View File
@@ -26,12 +26,14 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.psi.JetElement;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetVisitorVoid;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
@@ -77,7 +79,8 @@ public class DescriptorRendererTest extends JetLiteFixture {
JetFile psiFile = createPsiFile(null, fileName, loadFile(fileName));
AnalyzeExhaust analyzeExhaust =
AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
(JetFile) psiFile, myEnvironment.getCompilerDependencies());
(JetFile) psiFile, Collections.<AnalyzerScriptParameter>emptyList(),
myEnvironment.getCompilerDependencies());
final BindingContext bindingContext = analyzeExhaust.getBindingContext();
final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
psiFile.acceptChildren(new JetVisitorVoid() {
compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java
+5 -2
View File
@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic;
import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnosticFactory;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.BindingContextUtils;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -44,6 +45,7 @@ import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeConstructor;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -152,8 +154,9 @@ public abstract class ExpectedResolveData {
Project project = files.iterator().next().getProject();
JetStandardLibrary lib = JetStandardLibrary.getInstance();
AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files,
Predicates.<PsiFile>alwaysTrue(), jetCoreEnvironment.getCompilerDependencies());
AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, Collections.<AnalyzerScriptParameter>emptyList(),
Predicates.<PsiFile>alwaysTrue(),
jetCoreEnvironment.getCompilerDependencies());
BindingContext bindingContext = analyzeExhaust.getBindingContext();
for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
if (diagnostic.getFactory() instanceof UnresolvedReferenceDiagnosticFactory) {
compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java
+3
View File
@@ -22,6 +22,7 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.di.InjectorForTests;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.DescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -32,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
import java.util.Collections;
import java.util.List;
/**
@@ -65,6 +67,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
JetDeclaration aClass = declarations.get(0);
assert aClass instanceof JetClass;
AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(file,
Collections.<AnalyzerScriptParameter>emptyList(),
myEnvironment.getCompilerDependencies());
DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass);
WritableScopeImpl scope = new WritableScopeImpl(libraryScope, root, RedeclarationHandler.DO_NOTHING);
idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java
+2
View File
@@ -35,6 +35,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.BindingContextUtils;
import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -73,6 +74,7 @@ public class JetSourceNavigationHelper {
BindingContext bindingContext = AnalyzerFacadeProvider.getAnalyzerFacadeForProject(project).analyzeFiles(
project,
libraryFiles,
Collections.<AnalyzerScriptParameter>emptyList(),
Predicates.<PsiFile>alwaysTrue()).getBindingContext();
D descriptor = bindingContext.get(slice, fqName);
if (descriptor != null) {
idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java
+3
View File
@@ -31,6 +31,7 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
@@ -92,6 +93,7 @@ public final class AnalyzerFacadeWithCache {
// Need to resolve bodies in given file
AnalyzeExhaust exhaust = AnalyzerFacadeProvider.getAnalyzerFacadeForFile(file).analyzeBodiesInFiles(
file.getProject(),
Collections.<AnalyzerScriptParameter>emptyList(),
Predicates.<PsiFile>equalTo(file),
new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext()),
context);
@@ -135,6 +137,7 @@ public final class AnalyzerFacadeWithCache {
AnalyzeExhaust exhaust = AnalyzerFacadeProvider.getAnalyzerFacadeForFile(fileToCache)
.analyzeFiles(fileToCache.getProject(),
headerFiles,
Collections.<AnalyzerScriptParameter>emptyList(),
Predicates.<PsiFile>alwaysFalse());
return new Result<AnalyzeExhaust>(exhaust, PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
idea/src/org/jetbrains/jet/plugin/project/JSAnalyzerFacadeForIDEA.java
+4
View File
@@ -23,11 +23,13 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.analyzer.AnalyzerFacade;
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 org.jetbrains.k2js.analyze.AnalyzerFacadeForJS;
import java.util.Collection;
import java.util.List;
/**
* @author Pavel Talanov
@@ -43,6 +45,7 @@ public enum JSAnalyzerFacadeForIDEA implements AnalyzerFacade {
@Override
public AnalyzeExhaust analyzeFiles(@NotNull Project project,
@NotNull Collection<JetFile> files,
@NotNull List<AnalyzerScriptParameter> scriptParameters,
@NotNull Predicate<PsiFile> filesToAnalyzeCompletely) {
return AnalyzerFacadeForJS.analyzeFiles(files, filesToAnalyzeCompletely, new IDEAConfig(project), true);
}
@@ -50,6 +53,7 @@ public enum JSAnalyzerFacadeForIDEA implements AnalyzerFacade {
@NotNull
@Override
public AnalyzeExhaust analyzeBodiesInFiles(@NotNull Project project,
@NotNull List<AnalyzerScriptParameter> scriptParameters,
@NotNull Predicate<PsiFile> filesForBodiesResolve,
@NotNull BindingTrace traceContext,
@NotNull BodiesResolveContext bodiesResolveContext) {
injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java
+2
View File
@@ -60,6 +60,7 @@ public class AllInjectorsGenerator {
DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false);
generateInjectorForTopDownAnalyzerCommon(generator);
generator.addParameter(ModuleConfiguration.class);
generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class);
generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic");
}
@@ -77,6 +78,7 @@ public class AllInjectorsGenerator {
generator.addParameter(CompilerDependencies.class);
generator.addField(false, CompilerSpecialMode.class, null, new GivenExpression("compilerDependencies.getCompilerSpecialMode()"));
generator.addPublicField(JavaBridgeConfiguration.class);
generator.addField(JavaDescriptorResolver.class);
generator.addField(PsiClassFinderForJvm.class);
generator.generate("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJvm");
}
js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java
+14
View File
@@ -42,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;
@@ -78,6 +79,7 @@ public class InjectorForTopDownAnalyzerForJs {
private OverloadResolver overloadResolver;
private OverrideResolver overrideResolver;
private TypeHierarchyResolver typeHierarchyResolver;
private ScriptResolver scriptResolver;
public InjectorForTopDownAnalyzerForJs(
@NotNull Project project,
@@ -111,6 +113,7 @@ public class InjectorForTopDownAnalyzerForJs {
this.overloadResolver = new OverloadResolver();
this.overrideResolver = new OverrideResolver();
this.typeHierarchyResolver = new TypeHierarchyResolver();
this.scriptResolver = new ScriptResolver();
this.topDownAnalyzer.setBodyResolver(bodyResolver);
this.topDownAnalyzer.setContext(topDownAnalysisContext);
@@ -118,6 +121,7 @@ public class InjectorForTopDownAnalyzerForJs {
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);
@@ -131,6 +135,7 @@ public class InjectorForTopDownAnalyzerForJs {
this.bodyResolver.setCallResolver(callResolver);
this.bodyResolver.setDescriptorResolver(descriptorResolver);
this.bodyResolver.setExpressionTypingServices(expressionTypingServices);
this.bodyResolver.setScriptResolver(scriptResolver);
this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters);
this.bodyResolver.setTrace(observableBindingTrace);
@@ -189,8 +194,17 @@ public class InjectorForTopDownAnalyzerForJs {
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
js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java
+5 -3
View File
@@ -41,6 +41,7 @@ import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
import org.jetbrains.k2js.config.Config;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
@@ -87,12 +88,13 @@ public final class AnalyzerFacadeForJS {
Predicate<PsiFile> completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely);
TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(completely, false, false);
TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
completely, false, false, Collections.<AnalyzerScriptParameter>emptyList());
InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, JsConfiguration.jsLibConfiguration(project));
try {
injector.getTopDownAnalyzer().analyzeFiles(withJsLibAdded(files, config));
injector.getTopDownAnalyzer().analyzeFiles(withJsLibAdded(files, config), Collections.<AnalyzerScriptParameter>emptyList());
BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ?
new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) :
null;
@@ -112,7 +114,7 @@ public final class AnalyzerFacadeForJS {
final ModuleDescriptor owner = new ModuleDescriptor(Name.special("<module>"));
Predicate<PsiFile> completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely);
TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(completely, false, false);
TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(completely, false, false, Collections.<AnalyzerScriptParameter>emptyList());
InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
project, topDownAnalysisParameters, new ObservableBindingTrace(traceContext), owner, JsConfiguration.jsLibConfiguration(project));