From d6bf8876a34f82e0200f76c2f8dc2f0bc35a9731 Mon Sep 17 00:00:00 2001
From: Stepan Koltsov <stepan.koltsov@jetbrains.com>
Date: Wed, 23 May 2012 02:52:29 +0400
Subject: [PATCH] analyze kotlin scripts

---
 .../DeclarationDescriptorVisitor.java         |  4 ++
 .../lang/descriptors/ScriptDescriptor.java    | 50 ++++++++++++++++
 .../org/jetbrains/jet/lang/psi/JetScript.java |  8 +++
 .../jet/lang/resolve/BindingContext.java      |  1 +
 .../jet/lang/resolve/BodyResolver.java        | 25 ++++++++
 .../jet/lang/resolve/ImportsResolver.java     | 58 +++++++++++--------
 .../lang/resolve/TopDownAnalysisContext.java  | 13 +++++
 .../lang/resolve/TypeHierarchyResolver.java   | 19 +++++-
 .../expressions/ExpressionTypingServices.java |  2 +-
 .../AccessForwardDeclarationInScript.ktscript |  3 +
 .../tests/script/ComplexScript.ktscript       |  5 ++
 .../tests/script/SimpleScript.ktscript        |  1 +
 12 files changed, 162 insertions(+), 27 deletions(-)
 create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java
 create mode 100644 compiler/testData/diagnostics/tests/script/AccessForwardDeclarationInScript.ktscript
 create mode 100644 compiler/testData/diagnostics/tests/script/ComplexScript.ktscript
 create mode 100644 compiler/testData/diagnostics/tests/script/SimpleScript.ktscript

diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java
index 5a105a4703a..de75842143b 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java
@@ -52,6 +52,10 @@ public class DeclarationDescriptorVisitor<R, D> {
         return visitFunctionDescriptor(constructorDescriptor, data);
     }
 
+    public R visitScriptDescriptor(ScriptDescriptor scriptDescriptor, D data) {
+        return visitDeclarationDescriptor(scriptDescriptor, data);
+    }
+
     public R visitLocalVariableDescriptor(LocalVariableDescriptor descriptor, D data) {
         return visitVariableDescriptor(descriptor, data);
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java
new file mode 100644
index 00000000000..58b3e452209
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java
@@ -0,0 +1,50 @@
+/*
+ * 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.descriptors;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
+
+import java.util.Collections;
+
+/**
+ * @author Stepan Koltsov
+ */
+public class ScriptDescriptor extends DeclarationDescriptorImpl {
+    private JetType returnType;
+
+    public ScriptDescriptor(@Nullable DeclarationDescriptor containingDeclaration) {
+        super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(), "<script>");
+    }
+
+    public void initialize(@NotNull JetType returnType) {
+        this.returnType = returnType;
+    }
+
+    @Override
+    public DeclarationDescriptor substitute(TypeSubstitutor substitutor) {
+        throw new IllegalStateException("nothing to substitute in script");
+    }
+
+    @Override
+    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
+        return visitor.visitScriptDescriptor(this, data);
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetScript.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetScript.java
index 0c8d2045e48..972813ab6d5 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetScript.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetScript.java
@@ -17,8 +17,11 @@
 package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
+import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.List;
+
 /**
  * @author Stepan Koltsov
  */
@@ -33,6 +36,11 @@ public class JetScript extends JetDeclaration {
         return findNotNullChildByClass(JetBlockExpression.class);
     }
 
+    @NotNull
+    public List<JetImportDirective> getImportDirectives() {
+        return PsiTreeUtil.getChildrenOfTypeAsList(this, JetImportDirective.class);
+    }
+
     @Override
     public void accept(@NotNull JetVisitorVoid visitor) {
         visitor.visitScript(this);
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
index 674b7b5fbd4..5a413f46329 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
@@ -129,6 +129,7 @@ public interface BindingContext {
 
     WritableSlice<PsiElement, NamespaceDescriptor> NAMESPACE = Slices.<PsiElement, NamespaceDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
     WritableSlice<PsiElement, ClassDescriptor> CLASS = Slices.<PsiElement, ClassDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
+    WritableSlice<PsiElement, ScriptDescriptor> SCRIPT = Slices.<PsiElement, ScriptDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
     WritableSlice<JetTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = Slices.<JetTypeParameter, TypeParameterDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
     /** @see BindingContextUtils#recordFunctionDeclarationToDescriptor(BindingTrace, PsiElement, SimpleFunctionDescriptor)} */
     WritableSlice<PsiElement, SimpleFunctionDescriptor> FUNCTION = Slices.<PsiElement, SimpleFunctionDescriptor>sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
index 348b203428a..b5e7bd6b4ef 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
@@ -33,7 +33,10 @@ 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.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;
@@ -109,6 +112,8 @@ public class BodyResolver {
         resolveSecondaryConstructorBodies();
         resolveFunctionBodies();
 
+        resolveScripts();
+
         if (!topDownAnalysisParameters.isDeclaredLocally()) {
             computeDeferredTypes();
         }
@@ -613,4 +618,24 @@ 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,
+                    this.context.getRootScope(),
+                    DataFlowInfo.EMPTY,
+                    NO_EXPECTED_TYPE,
+                    false);
+            JetType returnType = expressionTypingServices.getBlockReturnedType(scope, declaration.getBlockExpression(), CoercionStrategy.NO_COERCION, context, trace);
+            descriptor.initialize(returnType);
+        }
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java
index d85043e6a13..a6fbd52b231 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java
@@ -77,34 +77,42 @@ public class ImportsResolver {
 
     private void processImports(boolean onlyClasses) {
         for (JetFile file : context.getNamespaceDescriptors().keySet()) {
-            JetScope rootScope = context.getRootScope();
             WritableScope namespaceScope = context.getNamespaceScopes().get(file);
-            Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope);
-            if (!onlyClasses) {
-                namespaceScope.clearImports();
-            }
-            Map<JetImportDirective, DeclarationDescriptor> resolvedDirectives = Maps.newHashMap();
-            Collection<JetImportDirective> defaultImportDirectives = Lists.newArrayList();
-            configuration.addDefaultImports(defaultImportDirectives);
-            for (JetImportDirective defaultImportDirective : defaultImportDirectives) {
-                TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); //not to trace errors of default imports
-                qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, namespaceScope, delayedImporter, temporaryTrace, onlyClasses);
-            }
+            processImportsInFile(onlyClasses, namespaceScope, file.getImportDirectives());
+        }
+        for (JetScript script : context.getScripts().keySet()) {
+            WritableScope scriptScope = context.getScriptScopes().get(script);
+            processImportsInFile(onlyClasses, scriptScope, script.getImportDirectives());
+        }
+    }
 
-            List<JetImportDirective> importDirectives = file.getImportDirectives();
+    private void processImportsInFile(boolean onlyClasses, WritableScope namespaceScope, List<JetImportDirective> importDirectives) {
+
+        JetScope rootScope = context.getRootScope();
+        Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope);
+        if (!onlyClasses) {
+            namespaceScope.clearImports();
+        }
+        Map<JetImportDirective, DeclarationDescriptor> resolvedDirectives = Maps.newHashMap();
+        Collection<JetImportDirective> defaultImportDirectives = Lists.newArrayList();
+        configuration.addDefaultImports(defaultImportDirectives);
+        for (JetImportDirective defaultImportDirective : defaultImportDirectives) {
+            TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); //not to trace errors of default imports
+            qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, namespaceScope, delayedImporter, temporaryTrace, onlyClasses);
+        }
+
+        for (JetImportDirective importDirective : importDirectives) {
+            Collection<? extends DeclarationDescriptor> descriptors =
+                qualifiedExpressionResolver.processImportReference(importDirective, rootScope, namespaceScope, delayedImporter, trace, onlyClasses);
+            if (descriptors.size() == 1) {
+                resolvedDirectives.put(importDirective, descriptors.iterator().next());
+            }
+        }
+        delayedImporter.processImports();
+
+        if (!onlyClasses) {
             for (JetImportDirective importDirective : importDirectives) {
-                Collection<? extends DeclarationDescriptor> descriptors =
-                    qualifiedExpressionResolver.processImportReference(importDirective, rootScope, namespaceScope, delayedImporter, trace, onlyClasses);
-                if (descriptors.size() == 1) {
-                    resolvedDirectives.put(importDirective, descriptors.iterator().next());
-                }
-            }
-            delayedImporter.processImports();
-
-            if (!onlyClasses) {
-                for (JetImportDirective importDirective : importDirectives) {
-                    reportUselessImport(importDirective, namespaceScope, resolvedDirectives);
-                }
+                reportUselessImport(importDirective, namespaceScope, resolvedDirectives);
             }
         }
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
index e9afa155b33..b982e93ab54 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
@@ -54,6 +54,9 @@ public class TopDownAnalysisContext {
 
     public final Map<JetDeclarationContainer, JetScope> normalScope = Maps.newHashMap();
 
+    private final Map<JetScript, ScriptDescriptor> scripts = Maps.newLinkedHashMap();
+    private final Map<JetScript, WritableScope> scriptScopes = Maps.newHashMap();
+
     private StringBuilder debugOutput;
 
 
@@ -120,6 +123,16 @@ public class TopDownAnalysisContext {
         return namespaceDescriptors;
     }
 
+    @NotNull
+    public Map<JetScript, ScriptDescriptor> getScripts() {
+        return scripts;
+    }
+
+    @NotNull
+    public Map<JetScript, WritableScope> getScriptScopes() {
+        return scriptScopes;
+    }
+
     public Map<JetParameter, PropertyDescriptor> getPrimaryConstructorParameterProperties() {
         return primaryConstructorParameterProperties;
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
index b14137e3621..cdd92a9cbbb 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
@@ -186,6 +186,12 @@ public class TypeHierarchyResolver {
             declaration.accept(new JetVisitorVoid() {
                 @Override
                 public void visitJetFile(JetFile file) {
+                    if (file.isScript()) {
+                        JetScript script = file.getScript();
+                        processScript(script);
+                        return;
+                    }
+
                     NamespaceDescriptorImpl namespaceDescriptor = namespaceFactory.createNamespaceDescriptorPathIfNeeded(
                             file, outerScope, RedeclarationHandler.DO_NOTHING);
                     context.getNamespaceDescriptors().put(file, namespaceDescriptor);
@@ -198,6 +204,17 @@ 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));
+                    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(
@@ -610,4 +627,4 @@ public class TypeHierarchyResolver {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java
index 984afc97d4b..33f6ca7835e 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java
@@ -187,7 +187,7 @@ public class ExpressionTypingServices {
     }
 
     @Nullable
-    /*package*/ JetType getBlockReturnedType(@NotNull JetScope outerScope, @NotNull JetBlockExpression expression, @NotNull CoercionStrategy coercionStrategyForLastExpression, ExpressionTypingContext context, BindingTrace trace) {
+    public JetType getBlockReturnedType(@NotNull JetScope outerScope, @NotNull JetBlockExpression expression, @NotNull CoercionStrategy coercionStrategyForLastExpression, ExpressionTypingContext context, BindingTrace trace) {
         List<JetElement> block = expression.getStatements();
         if (block.isEmpty()) {
             return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, context);
diff --git a/compiler/testData/diagnostics/tests/script/AccessForwardDeclarationInScript.ktscript b/compiler/testData/diagnostics/tests/script/AccessForwardDeclarationInScript.ktscript
new file mode 100644
index 00000000000..c0924df3df3
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/script/AccessForwardDeclarationInScript.ktscript
@@ -0,0 +1,3 @@
+val x = <!UNRESOLVED_REFERENCE!>y<!>
+
+val y = 2
diff --git a/compiler/testData/diagnostics/tests/script/ComplexScript.ktscript b/compiler/testData/diagnostics/tests/script/ComplexScript.ktscript
new file mode 100644
index 00000000000..19f6be0e2ab
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/script/ComplexScript.ktscript
@@ -0,0 +1,5 @@
+fun foo(x: Int) = 1
+
+val y = 2
+
+foo(y)
diff --git a/compiler/testData/diagnostics/tests/script/SimpleScript.ktscript b/compiler/testData/diagnostics/tests/script/SimpleScript.ktscript
new file mode 100644
index 00000000000..908945cd7a4
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/script/SimpleScript.ktscript
@@ -0,0 +1 @@
+val x = 1