Script parameters supported in LAZY mode

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java

@@ -50,6 +50,8 @@ import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
 import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
 import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
+import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
+import org.jetbrains.jet.lang.resolve.ScriptParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
@@ -98,6 +100,8 @@ public class InjectorForLazyResolveWithJava {
     private final CandidateResolver candidateResolver;
     private final JetImportsFactory jetImportsFactory;
     private final ScopeProvider scopeProvider;
+    private final ScriptBodyResolver scriptBodyResolver;
+    private final ScriptParameterResolver scriptParameterResolver;
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
@@ -149,6 +153,8 @@ public class InjectorForLazyResolveWithJava {
         this.candidateResolver = new CandidateResolver();
         this.jetImportsFactory = new JetImportsFactory();
         this.scopeProvider = new ScopeProvider(getResolveSession());
+        this.scriptBodyResolver = new ScriptBodyResolver();
+        this.scriptParameterResolver = new ScriptParameterResolver();
         this.descriptorDeserializers = new DescriptorDeserializers();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager);
@@ -159,6 +165,8 @@ public class InjectorForLazyResolveWithJava {
         this.resolveSession.setJetImportFactory(jetImportsFactory);
         this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
         this.resolveSession.setScopeProvider(scopeProvider);
+        this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
+        this.resolveSession.setScriptParameterResolver(scriptParameterResolver);
         this.resolveSession.setTypeResolver(typeResolver);
 
         javaClassFinder.setProject(project);
@@ -224,6 +232,10 @@ public class InjectorForLazyResolveWithJava {
 
         jetImportsFactory.setProject(project);
 
+        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
+
+        scriptParameterResolver.setDependencyClassByQualifiedNameResolver(javaDescriptorResolver);
+
         deserializedDescriptorResolver.setDeserializers(descriptorDeserializers);
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -195,8 +195,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
         this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         this.topDownAnalyzer.setProject(project);
-        this.topDownAnalyzer.setScriptBodyResolver(scriptBodyResolver);
-        this.topDownAnalyzer.setScriptParameterResolver(scriptParameterResolver);
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
 

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java

@@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
+import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
@@ -41,6 +42,8 @@ import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
 import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
 import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
+import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
+import org.jetbrains.jet.lang.resolve.ScriptParameterResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -56,6 +59,7 @@ public class InjectorForLazyResolve {
     private final DeclarationProviderFactory declarationProviderFactory;
     private final BindingTrace bindingTrace;
     private final ResolveSession resolveSession;
+    private final DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -73,6 +77,8 @@ public class InjectorForLazyResolve {
     private final CandidateResolver candidateResolver;
     private final JetImportsFactory jetImportsFactory;
     private final ScopeProvider scopeProvider;
+    private final ScriptBodyResolver scriptBodyResolver;
+    private final ScriptParameterResolver scriptParameterResolver;
     
     public InjectorForLazyResolve(
         @NotNull Project project,
@@ -89,6 +95,7 @@ public class InjectorForLazyResolve {
         this.declarationProviderFactory = declarationProviderFactory;
         this.bindingTrace = bindingTrace;
         this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
+        this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -106,12 +113,16 @@ public class InjectorForLazyResolve {
         this.candidateResolver = new CandidateResolver();
         this.jetImportsFactory = new JetImportsFactory();
         this.scopeProvider = new ScopeProvider(getResolveSession());
+        this.scriptBodyResolver = new ScriptBodyResolver();
+        this.scriptParameterResolver = new ScriptParameterResolver();
 
         this.resolveSession.setAnnotationResolve(annotationResolver);
         this.resolveSession.setDescriptorResolver(descriptorResolver);
         this.resolveSession.setJetImportFactory(jetImportsFactory);
         this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
         this.resolveSession.setScopeProvider(scopeProvider);
+        this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
+        this.resolveSession.setScriptParameterResolver(scriptParameterResolver);
         this.resolveSession.setTypeResolver(typeResolver);
 
         annotationResolver.setCallResolver(callResolver);
@@ -165,6 +176,10 @@ public class InjectorForLazyResolve {
 
         jetImportsFactory.setProject(project);
 
+        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
+
+        scriptParameterResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy);
+
     }
     
     @PreDestroy

compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java

@@ -149,8 +149,6 @@ public class InjectorForTopDownAnalyzerBasic {
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
         this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         this.topDownAnalyzer.setProject(project);
-        this.topDownAnalyzer.setScriptBodyResolver(scriptBodyResolver);
-        this.topDownAnalyzer.setScriptParameterResolver(scriptParameterResolver);
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java

@@ -252,10 +252,10 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
         if (primaryConstructor == null) return getScopeForMemberDeclarationResolution();
 
         WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, primaryConstructor, RedeclarationHandler.DO_NOTHING, "Scope with constructor parameters in " + getName());
-        for (ValueParameterDescriptor valueParameterDescriptor : primaryConstructor.getValueParameters()) {
+        for (int i = 0; i < originalClassInfo.getPrimaryConstructorParameters().size(); i++) {
-            JetParameter jetParameter = originalClassInfo.getPrimaryConstructorParameters().get(valueParameterDescriptor.getIndex());
+            JetParameter jetParameter = originalClassInfo.getPrimaryConstructorParameters().get(i);
             if (jetParameter.getValOrVarNode() == null) {
-                scope.addVariableDescriptor(valueParameterDescriptor);
+                scope.addVariableDescriptor(primaryConstructor.getValueParameters().get(i));
             }
         }
         scope.changeLockLevel(WritableScope.LockLevel.READING);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo;
+import org.jetbrains.jet.lang.resolve.lazy.data.JetScriptInfo;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.ClassMemberDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -227,10 +228,20 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         if (primaryConstructor != null) {
             List<ValueParameterDescriptor> valueParameterDescriptors = primaryConstructor.getValueParameters();
             List<? extends JetParameter> primaryConstructorParameters = classInfo.getPrimaryConstructorParameters();
-            assert valueParameterDescriptors.size() == primaryConstructorParameters.size() : "From descriptor: " + valueParameterDescriptors.size() + " but from PSI: " + primaryConstructorParameters.size();
             for (ValueParameterDescriptor valueParameterDescriptor : valueParameterDescriptors) {
+                if (!name.equals(valueParameterDescriptor.getName())) continue;
+
+                // SCRIPT: Adding script parameters as properties
+                if (classInfo instanceof JetScriptInfo) {
+                    result.add(ScriptDescriptorImpl.createPropertyFromScriptParameter(
+                            resolveSession.getScriptDescriptor(((JetScriptInfo) classInfo).getScript()), valueParameterDescriptor)
+                    );
+                    continue;
+                }
+
+                assert valueParameterDescriptors.size() == primaryConstructorParameters.size() : "From descriptor: " + valueParameterDescriptors.size() + " but from PSI: " + primaryConstructorParameters.size();
                 JetParameter parameter = primaryConstructorParameters.get(valueParameterDescriptor.getIndex());
-                if (parameter.getValOrVarNode() != null && name.equals(parameter.getNameAsName())) {
+                if (parameter.getValOrVarNode() != null) {
                     PropertyDescriptor propertyDescriptor =
                             resolveSession.getDescriptorResolver().resolvePrimaryConstructorParameterToAProperty(
                                     thisDescriptor,
@@ -356,27 +367,36 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
 
     @Nullable
     private ConstructorDescriptor resolvePrimaryConstructor() {
-        ConstructorDescriptor primaryConstructor = null;
         if (GENERATE_CONSTRUCTORS_FOR.contains(thisDescriptor.getKind())) {
-            JetClassOrObject classOrObject = declarationProvider.getOwnerInfo().getCorrespondingClassOrObject();
+            JetClassLikeInfo ownerInfo = declarationProvider.getOwnerInfo();
-            if (!thisDescriptor.getKind().isSingleton()) {
+            JetClassOrObject classOrObject = ownerInfo.getCorrespondingClassOrObject();
+            // SCRIPT: Creating a primary constructor for a script class
+            if (ownerInfo instanceof JetScriptInfo) {
+                ScriptDescriptor scriptDescriptor = resolveSession.getScriptDescriptor(((JetScriptInfo) ownerInfo).getScript());
+                ConstructorDescriptorImpl constructor = ScriptDescriptorImpl.createConstructor(scriptDescriptor,
+                                                                                               scriptDescriptor.getScriptCodeDescriptor()
+                                                                                                       .getValueParameters());
+                setDeferredReturnType(constructor);
+                return constructor;
+            }
+            else if (!thisDescriptor.getKind().isSingleton() && classOrObject instanceof JetClass) {
                 JetClass jetClass = (JetClass) classOrObject;
                 ConstructorDescriptorImpl constructor = resolveSession.getDescriptorResolver()
                         .resolvePrimaryConstructorDescriptor(thisDescriptor.getScopeForClassHeaderResolution(),
                                                              thisDescriptor,
                                                              jetClass,
                                                              trace);
-                primaryConstructor = constructor;
                 setDeferredReturnType(constructor);
+                return constructor;
             }
             else {
                 ConstructorDescriptorImpl constructor =
                         DescriptorResolver.createAndRecordPrimaryConstructorForObject(classOrObject, thisDescriptor, trace);
                 setDeferredReturnType(constructor);
-                primaryConstructor = constructor;
+                return constructor;
             }
         }
-        return primaryConstructor;
+        return null;
     }
 
     private void setDeferredReturnType(@NotNull ConstructorDescriptorImpl descriptor) {

compiler/frontend/src/org/jetbrains/jet/lang/types/DependencyClassByQualifiedNameResolverDummyImpl.java

@@ -19,10 +19,15 @@ package org.jetbrains.jet.lang.types;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 public class DependencyClassByQualifiedNameResolverDummyImpl implements DependencyClassByQualifiedNameResolver {
     @Override
     public ClassDescriptor resolveClass(@NotNull FqName qualifiedName) {
+        if (qualifiedName.isRoot()) return null;
+        if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(qualifiedName.parent())) {
+            return KotlinBuiltIns.getInstance().getBuiltInClassByName(qualifiedName.shortName());
+        }
         return null;
     }
 }

core/descriptors/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptorImpl.java

@@ -130,31 +130,50 @@ public class ScriptDescriptorImpl extends DeclarationDescriptorNonRootImpl imple
 
     public void setValueParameters(@NotNull List<ValueParameterDescriptor> valueParameters) {
         this.valueParameters = valueParameters;
-        ConstructorDescriptorImpl constructorDescriptor =
-                ConstructorDescriptorImpl.create(classDescriptor, Annotations.EMPTY, true)
-                        .initialize(Collections.<TypeParameterDescriptor>emptyList(), valueParameters, Visibilities.PUBLIC, false);
-        constructorDescriptor.setReturnType(classDescriptor.getDefaultType());
 
+        ConstructorDescriptorImpl constructorDescriptor = createConstructor(this, valueParameters);
+        constructorDescriptor.setReturnType(classDescriptor.getDefaultType());
         classDescriptor.getConstructors().add(constructorDescriptor);
         classDescriptor.setPrimaryConstructor(constructorDescriptor);
 
-        for (ValueParameterDescriptor parameter : valueParameters) {
+        for (ValueParameterDescriptor valueParameter : valueParameters) {
-            PropertyDescriptorImpl propertyDescriptor = PropertyDescriptorImpl.create(classDescriptor,
+            classScope.addPropertyDescriptor(createPropertyFromScriptParameter(this, valueParameter));
-                                                                                      Annotations.EMPTY,
-                                                                                      Modality.FINAL,
-                                                                                      Visibilities.PUBLIC,
-                                                                                      false,
-                                                                                      parameter.getName(),
-                                                                                      CallableMemberDescriptor.Kind.DECLARATION);
-            propertyDescriptor.setType(
-                    parameter.getType(),
-                    Collections.<TypeParameterDescriptor>emptyList(),
-                    classDescriptor.getThisAsReceiverParameter(), ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER);
-            propertyDescriptor.initialize(null, null);
-            classScope.addPropertyDescriptor(propertyDescriptor);
         }
     }
 
+    @NotNull
+    public static ConstructorDescriptorImpl createConstructor(
+            @NotNull ScriptDescriptor scriptDescriptor, @NotNull List<ValueParameterDescriptor> valueParameters
+    ) {
+        return ConstructorDescriptorImpl.create(scriptDescriptor.getClassDescriptor(), Annotations.EMPTY, true)
+                .initialize(
+                        Collections.<TypeParameterDescriptor>emptyList(),
+                        valueParameters,
+                        Visibilities.PUBLIC,
+                        false
+                );
+    }
+
+    @NotNull
+    public static PropertyDescriptor createPropertyFromScriptParameter(
+            @NotNull ScriptDescriptor scriptDescriptor,
+            @NotNull ValueParameterDescriptor parameter
+    ) {
+        PropertyDescriptorImpl propertyDescriptor = PropertyDescriptorImpl.create(scriptDescriptor.getClassDescriptor(),
+                                                                                  Annotations.EMPTY,
+                                                                                  Modality.FINAL,
+                                                                                  Visibilities.PUBLIC,
+                                                                                  false,
+                                                                                  parameter.getName(),
+                                                                                  CallableMemberDescriptor.Kind.DECLARATION);
+        propertyDescriptor.setType(
+                parameter.getType(),
+                Collections.<TypeParameterDescriptor>emptyList(),
+                scriptDescriptor.getThisAsReceiverParameter(), ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER);
+        propertyDescriptor.initialize(null, null);
+        return propertyDescriptor;
+    }
+
     @Override
     @NotNull
     public ClassDescriptor getClassDescriptor() {

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt

@@ -216,6 +216,8 @@ private fun generatorForLazyResolve() =
             parameter(javaClass<BindingTrace>())
 
             publicField(javaClass<ResolveSession>())
+
+            field(javaClass<DependencyClassByQualifiedNameResolverDummyImpl>())
         }
 
 private fun generator(

js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java

@@ -149,8 +149,6 @@ public class InjectorForTopDownAnalyzerForJs {
         this.topDownAnalyzer.setOverrideResolver(overrideResolver);
         this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider);
         this.topDownAnalyzer.setProject(project);
-        this.topDownAnalyzer.setScriptBodyResolver(scriptBodyResolver);
-        this.topDownAnalyzer.setScriptParameterResolver(scriptParameterResolver);
         this.topDownAnalyzer.setTrace(bindingTrace);
         this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);