generate bytecode for script

It is just prototype

* does not make top level symbols visible as class members yet
* does not take parameters
* Script class name is hardcoded now

compiler/backend/src/org/jetbrains/jet/codegen/ClosureAnnotator.java

@@ -86,8 +86,13 @@ public class ClosureAnnotator {
 
     private void mapFilesToNamespaces(Collection<JetFile> files) {
         for (JetFile file : files) {
-            FqName fqName = JetPsiUtil.getFQName(file);
-            namespaceName2Files.putValue(fqName, file);
+            if (file.isScript()) {
+                namespaceName2Files.putValue(FqName.ROOT, file);
+            }
+            else {
+                FqName fqName = JetPsiUtil.getFQName(file);
+                namespaceName2Files.putValue(fqName, file);
+            }
         }
     }
 

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -1340,7 +1340,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
         //    assert !superCall;
         //    callableMethod = ClosureCodegen.asCallableMethod((FunctionDescriptor) fd);
         //}
-        if (fd instanceof ExpressionAsFunctionDescriptor || (fd instanceof SimpleFunctionDescriptor && fd.getContainingDeclaration() instanceof FunctionDescriptor)) {
+        if (fd instanceof ExpressionAsFunctionDescriptor || (fd instanceof SimpleFunctionDescriptor && (fd.getContainingDeclaration() instanceof FunctionDescriptor || fd.getContainingDeclaration() instanceof ScriptDescriptor))) {
             SimpleFunctionDescriptor invoke = CodegenUtil.createInvoke((FunctionDescriptor) fd);
             callableMethod = ClosureCodegen.asCallableMethod(invoke);
         }

compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java

@@ -80,6 +80,9 @@ public class NamespaceCodegen {
             else if (declaration instanceof JetClassOrObject) {
                 state.getInjector().getClassCodegen().generate(context, (JetClassOrObject) declaration);
             }
+            else if (declaration instanceof JetScript) {
+                state.getInjector().getScriptCodegen().generate(context, (JetScript) declaration);
+            }
 //            else if (declaration instanceof JetFile) {
 //                JetFile childNamespace = (JetFile) declaration;
 //                state.forNamespace(childNamespace).generate(childNamespace);

compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java

@@ -0,0 +1,102 @@
+/*
+ * 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.codegen;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
+import org.jetbrains.jet.lang.psi.JetScript;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.java.JdkNames;
+import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
+import org.objectweb.asm.MethodAdapter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.commons.InstructionAdapter;
+import sun.tools.tree.InlineReturnStatement;
+
+import javax.inject.Inject;
+
+/**
+ * @author Stepan Koltsov
+ */
+public class ScriptCodegen {
+
+    public static final String LAST_EXPRESSION_VALUE_FIELD_NAME = "rv";
+
+    @NotNull
+    private GenerationState state;
+    @NotNull
+    private ClassFileFactory classFileFactory;
+    @NotNull
+    private JetTypeMapper jetTypeMapper;
+
+
+    @Inject
+    public void setState(@NotNull GenerationState state) {
+        this.state = state;
+    }
+
+    @Inject
+    public void setClassFileFactory(@NotNull ClassFileFactory classFileFactory) {
+        this.classFileFactory = classFileFactory;
+    }
+
+    @Inject
+    public void setJetTypeMapper(@NotNull JetTypeMapper jetTypeMapper) {
+        this.jetTypeMapper = jetTypeMapper;
+    }
+
+
+
+    public void generate(CodegenContext context, JetScript scriptDeclaration) {
+        ScriptDescriptor scriptDescriptor = (ScriptDescriptor) state.getBindingContext().get(BindingContext.SCRIPT, scriptDeclaration);
+        ClassBuilder classBuilder = classFileFactory.newVisitor("Script.class");
+        classBuilder.defineClass(scriptDeclaration,
+                Opcodes.V1_6,
+                Opcodes.ACC_PUBLIC,
+                "Script",
+                null,
+                JdkNames.JL_OBJECT.getInternalName(),
+                new String[0]);
+
+        Type blockType = jetTypeMapper.mapType(scriptDescriptor.getReturnType(), MapTypeMode.VALUE);
+
+        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);
+
+        mv.visitCode();
+
+        InstructionAdapter instructionAdapter = new InstructionAdapter(mv);
+
+        instructionAdapter.load(0, Type.getObjectType("Script"));
+        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());
+        if (stackValue.type != Type.VOID_TYPE) {
+            instructionAdapter.putfield("Script", LAST_EXPRESSION_VALUE_FIELD_NAME, blockType.getDescriptor());
+        }
+
+        instructionAdapter.areturn(Type.VOID_TYPE);
+        mv.visitMaxs(-1, -1);
+        mv.visitEnd();
+
+        classBuilder.done();
+    }
+}

compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java

@@ -28,6 +28,7 @@ import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.codegen.ClassBuilderFactory;
 import org.jetbrains.jet.codegen.JetTypeMapper;
 import org.jetbrains.jet.codegen.ClassCodegen;
+import org.jetbrains.jet.codegen.ScriptCodegen;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
 import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.ClosureAnnotator;
@@ -56,6 +57,7 @@ public class InjectorForJvmCodegen {
     private final ClassBuilderFactory classBuilderFactory;
     private JetTypeMapper jetTypeMapper;
     private ClassCodegen classCodegen;
+    private ScriptCodegen scriptCodegen;
     private IntrinsicMethods intrinsics;
     private ClassFileFactory classFileFactory;
     private ClosureAnnotator closureAnnotator;
@@ -80,6 +82,7 @@ public class InjectorForJvmCodegen {
         this.classBuilderFactory = classBuilderFactory;
         this.jetTypeMapper = new JetTypeMapper();
         this.classCodegen = new ClassCodegen();
+        this.scriptCodegen = new ScriptCodegen();
         this.intrinsics = new IntrinsicMethods();
         this.classFileFactory = new ClassFileFactory();
         this.closureAnnotator = new ClosureAnnotator();
@@ -93,6 +96,10 @@ public class InjectorForJvmCodegen {
         this.classCodegen.setJetTypeMapper(jetTypeMapper);
         this.classCodegen.setState(generationState);
 
+        this.scriptCodegen.setClassFileFactory(classFileFactory);
+        this.scriptCodegen.setJetTypeMapper(jetTypeMapper);
+        this.scriptCodegen.setState(generationState);
+
         this.intrinsics.setMyProject(project);
         this.intrinsics.setMyStdLib(jetStandardLibrary);
 
@@ -130,6 +137,10 @@ public class InjectorForJvmCodegen {
         return this.classCodegen;
     }
 
+    public ScriptCodegen getScriptCodegen() {
+        return this.scriptCodegen;
+    }
+
     public IntrinsicMethods getIntrinsics() {
         return this.intrinsics;
     }