CodegenContext replaced with MethodContext in ExpressionCodegen

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

@@ -22,13 +22,14 @@ import org.jetbrains.asm4.MethodVisitor;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.context.ClassContext;
 import org.jetbrains.jet.codegen.state.GenerationState;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.name.Name;
 
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
@@ -45,7 +46,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen {
 
     private MethodVisitor clInitMethod;
 
-    private  ExpressionCodegen clInitCodegen;
+    private ExpressionCodegen clInitCodegen;
 
     protected ClassBodyCodegen(
             @NotNull JetClassOrObject aClass,
@@ -176,7 +177,14 @@ public abstract class ClassBodyCodegen extends MemberCodegen {
             if (clInitCodegen == null) {
                 MethodVisitor method = createOrGetClInitMethod();
                 method.visitCode();
-                clInitCodegen = new ExpressionCodegen(method, new FrameMap(), Type.VOID_TYPE, context, state);
+                SimpleFunctionDescriptorImpl clInit =
+                        new SimpleFunctionDescriptorImpl(descriptor, Collections.<AnnotationDescriptor>emptyList(),
+                                                         Name.special("<clinit>"),
+                                                         CallableMemberDescriptor.Kind.SYNTHESIZED);
+                clInit.initialize(null, null, Collections.<TypeParameterDescriptor>emptyList(),
+                                  Collections.<ValueParameterDescriptor>emptyList(), null, null, Visibilities.PRIVATE, false);
+
+                clInitCodegen = new ExpressionCodegen(method, new FrameMap(), Type.VOID_TYPE, context.intoFunction(clInit), state);
             }
         }
         return clInitCodegen;

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

@@ -95,7 +95,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     private final Type returnType;
 
     private final BindingContext bindingContext;
-    final CodegenContext context;
+    final MethodContext context;
     private final CodegenStatementVisitor statementVisitor;
 
     private final Stack<BlockStackElement> blockStackElements = new Stack<BlockStackElement>();
@@ -155,11 +155,11 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
 
     public ExpressionCodegen(
-            MethodVisitor v,
-            FrameMap myMap,
-            Type returnType,
-            CodegenContext context,
-            GenerationState state
+            @NotNull MethodVisitor v,
+            @NotNull FrameMap myMap,
+            @NotNull Type returnType,
+            @NotNull MethodContext context,
+            @NotNull GenerationState state
     ) {
         this.myFrameMap = myMap;
         this.typeMapper = state.getTypeMapper();

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

@@ -19,7 +19,6 @@ package org.jetbrains.jet.codegen;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.MethodVisitor;
 import org.jetbrains.asm4.Type;
-import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.context.MethodContext;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
 import org.jetbrains.jet.codegen.state.GenerationState;

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

@@ -20,6 +20,7 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.util.Pair;
+import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.AnnotationVisitor;
@@ -66,6 +67,7 @@ import static org.jetbrains.jet.codegen.AsmUtil.*;
 import static org.jetbrains.jet.codegen.CodegenUtil.*;
 import static org.jetbrains.jet.codegen.binding.CodegenBinding.*;
 import static org.jetbrains.jet.lang.resolve.BindingContextUtils.callableDescriptorToDeclaration;
+import static org.jetbrains.jet.lang.resolve.BindingContextUtils.descriptorToDeclaration;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.*;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isKindOf;
 import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.JAVA_STRING_TYPE;
@@ -1322,7 +1324,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
     }
 
 
-    private void generateDelegationToTraitImpl(@NotNull FunctionDescriptor fun, @NotNull FunctionDescriptor inheritedFun) {
+    private void generateDelegationToTraitImpl(final @NotNull FunctionDescriptor fun, @NotNull FunctionDescriptor inheritedFun) {
         DeclarationDescriptor containingDeclaration = fun.getContainingDeclaration();
         if (!(containingDeclaration instanceof ClassDescriptor)) {
             return;
@@ -1339,20 +1341,21 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         Method methodToGenerate = delegateInfo.methodToGenerate;
         Method methodInTrait = delegateInfo.methodInTrait;
 
-        MethodVisitor mv = v.newMethod(myClass, flags, methodToGenerate.getName(), methodToGenerate.getDescriptor(), null, null);
+        PsiElement origin = descriptorToDeclaration(bindingContext, fun);
+        MethodVisitor mv = v.newMethod(origin, flags, methodToGenerate.getName(), methodToGenerate.getDescriptor(), null, null);
         AnnotationCodegen.forMethod(mv, typeMapper).genAnnotations(fun);
 
-        writeAnnotationForDelegateToTraitImpl(fun, inheritedFun, mv);
-
         if (state.getClassBuilderMode() == ClassBuilderMode.STUBS) {
             genStubCode(mv);
         }
         else if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
+            writeAnnotationForDelegateToTraitImpl(fun, inheritedFun, mv);
+
             Type returnType = methodToGenerate.getReturnType();
 
             mv.visitCode();
             FrameMap frameMap = context.prepareFrame(typeMapper);
-            ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, returnType, context, state);
+            ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, returnType, context.intoFunction(inheritedFun), state);
             codegen.generateThisOrOuter(descriptor, false);    // ??? wouldn't it be addClosureToConstructorParameters good idea to put it?
 
             Type[] argTypes = methodToGenerate.getArgumentTypes();

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

@@ -28,7 +28,9 @@ import org.jetbrains.asm4.MethodVisitor;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.state.GenerationState;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -38,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.io.File;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.asm4.Opcodes.*;
@@ -159,7 +162,7 @@ public class NamespaceCodegen extends MemberCodegen {
                 }
             }
 
-            generateStaticInitializers(builder, file);
+            generateStaticInitializers(descriptor, builder, file);
 
             builder.done();
         }
@@ -203,16 +206,24 @@ public class NamespaceCodegen extends MemberCodegen {
         }
     }
 
-    private void generateStaticInitializers(@NotNull ClassBuilder builder, @NotNull JetFile file) {
+    private void generateStaticInitializers(NamespaceDescriptor descriptor, @NotNull ClassBuilder builder, @NotNull JetFile file) {
         List<JetProperty> properties = collectPropertiesToInitialize(file);
         if (properties.isEmpty()) return;
 
-        MethodVisitor mv = builder.newMethod(file, ACC_PUBLIC | ACC_STATIC, "<clinit>", "()V", null, null);
+        MethodVisitor mv = builder.newMethod(file, ACC_STATIC, "<clinit>", "()V", null, null);
         if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
             mv.visitCode();
 
             FrameMap frameMap = new FrameMap();
-            ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, CodegenContext.STATIC, state);
+
+            SimpleFunctionDescriptorImpl clInit =
+                    new SimpleFunctionDescriptorImpl(descriptor, Collections.<AnnotationDescriptor>emptyList(),
+                                                     Name.special("<clinit>"),
+                                                     CallableMemberDescriptor.Kind.SYNTHESIZED);
+            clInit.initialize(null, null, Collections.<TypeParameterDescriptor>emptyList(),
+                              Collections.<ValueParameterDescriptor>emptyList(), null, null, Visibilities.PRIVATE, false);
+
+            ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, CodegenContext.STATIC.intoFunction(clInit), state);
 
             for (JetDeclaration declaration : properties) {
                 ImplementationBodyCodegen.