subclasses of CodegenContext moved to upper level

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

@@ -1491,7 +1491,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         boolean isInsideClass = !isFakeOverride &&
                                 (((containingDeclaration == null && !context.hasThisDescriptor() ||
                                    context.hasThisDescriptor() && containingDeclaration == context.getThisDescriptor()) ||
-                                  (context.getParentContext() instanceof CodegenContext.NamespaceContext) &&
+                                  (context.getParentContext() instanceof NamespaceContext) &&
                                   context.getParentContext().getContextDescriptor() == containingDeclaration)
                                  && contextKind() != OwnerKind.TRAIT_IMPL);
         Method getter = null;
@@ -1673,7 +1673,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                     if (enclosed != context.getThisDescriptor()) {
                         CodegenContext c = context;
                         //noinspection ConstantConditions
-                        while (!(c instanceof CodegenContext.ClassContext) ||
+                        while (!(c instanceof ClassContext) ||
                                !DescriptorUtils.isSubclass(c.getThisDescriptor(), enclosed)) {
                             c = c.getParentContext();
                             assert c != null;
@@ -1900,12 +1900,12 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         CodegenContext cur = context;
         StackValue result = StackValue.local(0, OBJECT_TYPE);
         while (cur != null) {
-            if (cur instanceof CodegenContext.MethodContext && !(cur instanceof CodegenContext.ConstructorContext)) {
+            if (cur instanceof MethodContext && !(cur instanceof ConstructorContext)) {
                 cur = cur.getParentContext();
             }
 
-            if (cur instanceof CodegenContext.ScriptContext) {
-                CodegenContext.ScriptContext scriptContext = (CodegenContext.ScriptContext) cur;
+            if (cur instanceof ScriptContext) {
+                ScriptContext scriptContext = (ScriptContext) cur;
 
                 JvmClassName currentScriptClassName =
                         classNameForScriptDescriptor(state.getBindingContext(),
@@ -1927,7 +1927,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             assert cur != null;
             result = cur.getOuterExpression(result, false);
 
-            if (cur instanceof CodegenContext.ConstructorContext) {
+            if (cur instanceof ConstructorContext) {
                 cur = cur.getParentContext();
             }
             assert cur != null;
@@ -1945,7 +1945,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         Type type = asmType(calleeContainingClass.getDefaultType());
         StackValue result = StackValue.local(0, type);
         while (cur != null) {
-            if (cur instanceof CodegenContext.MethodContext && !(cur instanceof CodegenContext.ConstructorContext)) {
+            if (cur instanceof MethodContext && !(cur instanceof ConstructorContext)) {
                 cur = cur.getParentContext();
             }
 
@@ -1963,7 +1963,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
             result = cur.getOuterExpression(result, false);
 
-            if (cur instanceof CodegenContext.ConstructorContext) {
+            if (cur instanceof ConstructorContext) {
                 cur = cur.getParentContext();
             }
             assert cur != null;

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

@@ -26,6 +26,7 @@ import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.asm4.commons.Method;
 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.signature.kotlin.JetMethodAnnotationWriter;
 import org.jetbrains.jet.codegen.signature.kotlin.JetValueParameterAnnotationWriter;
@@ -80,7 +81,7 @@ public class FunctionCodegen {
             @Nullable String propertyTypeSignature, FunctionDescriptor functionDescriptor
     ) {
 
-        CodegenContext.MethodContext funContext = owner.intoFunction(functionDescriptor);
+        MethodContext funContext = owner.intoFunction(functionDescriptor);
 
         final JetExpression bodyExpression = f.getBodyExpression();
         generatedMethod(bodyExpression, jvmMethod, needJetAnnotations, propertyTypeSignature, funContext, functionDescriptor, f);
@@ -90,7 +91,7 @@ public class FunctionCodegen {
             JetExpression bodyExpressions,
             JvmMethodSignature jvmSignature,
             boolean needJetAnnotations, @Nullable String propertyTypeSignature,
-            CodegenContext.MethodContext context,
+            MethodContext context,
             FunctionDescriptor functionDescriptor,
             JetDeclarationWithBody fun
     ) {
@@ -422,7 +423,7 @@ public class FunctionCodegen {
     }
 
     static void generateDefaultIfNeeded(
-            CodegenContext.MethodContext owner,
+            MethodContext owner,
             GenerationState state,
             ClassBuilder v,
             Method jvmSignature,
@@ -482,7 +483,7 @@ public class FunctionCodegen {
     }
 
     private static void generateDefaultImpl(
-            CodegenContext.MethodContext owner,
+            MethodContext owner,
             GenerationState state,
             Method jvmSignature,
             FunctionDescriptor functionDescriptor,

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

@@ -26,10 +26,7 @@ import org.jetbrains.asm4.MethodVisitor;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.asm4.commons.Method;
-import org.jetbrains.jet.codegen.context.CalculatedClosure;
-import org.jetbrains.jet.codegen.context.CodegenBinding;
-import org.jetbrains.jet.codegen.context.CodegenContext;
-import org.jetbrains.jet.codegen.context.MutableClosure;
+import org.jetbrains.jet.codegen.context.*;
 import org.jetbrains.jet.codegen.signature.*;
 import org.jetbrains.jet.codegen.signature.kotlin.JetMethodAnnotationWriter;
 import org.jetbrains.jet.codegen.signature.kotlin.JetValueParameterAnnotationWriter;
@@ -560,7 +557,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         ConstructorDescriptor constructorDescriptor = bindingContext.get(BindingContext.CONSTRUCTOR, myClass);
 
-        final CodegenContext.ConstructorContext constructorContext = context.intoConstructor(constructorDescriptor);
+        final ConstructorContext constructorContext = context.intoConstructor(constructorDescriptor);
 
         lookupConstructorExpressionsInClosureIfPresent(constructorContext);
 
@@ -599,7 +596,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
     private void generatePrimiryConstructorImpl(
             ConstructorDescriptor constructorDescriptor,
-            CodegenContext.ConstructorContext constructorContext,
+            ConstructorContext constructorContext,
             JvmMethodSignature constructorMethod,
             CallableMethod callableMethod,
             boolean hasThis0,
@@ -793,7 +790,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         generateDelegates(superClass, delegateContext, field);
     }
 
-    private void lookupConstructorExpressionsInClosureIfPresent(final CodegenContext.ConstructorContext constructorContext) {
+    private void lookupConstructorExpressionsInClosureIfPresent(final ConstructorContext constructorContext) {
         final JetVisitorVoid visitor = new JetVisitorVoid() {
             @Override
             public void visitJetElement(JetElement e) {

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

@@ -23,6 +23,7 @@ import org.jetbrains.asm4.MethodVisitor;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.context.CodegenContext;
+import org.jetbrains.jet.codegen.context.ScriptContext;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
@@ -94,8 +95,8 @@ public class ScriptCodegen {
         ClassDescriptor classDescriptorForScript = bindingContext.get(CLASS_FOR_FUNCTION, scriptDescriptor);
         assert classDescriptorForScript != null;
 
-        CodegenContext.ScriptContext context =
-                (CodegenContext.ScriptContext) CodegenContext.STATIC
+        ScriptContext context =
+                (ScriptContext) CodegenContext.STATIC
                         .intoScript(scriptDescriptor, classDescriptorForScript);
 
         JvmClassName className = bindingContext.get(FQN, classDescriptorForScript);

compiler/backend/src/org/jetbrains/jet/codegen/context/AnonymousClassContext.java

@@ -0,0 +1,53 @@
+/*
+ * 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.context;
+
+import org.jetbrains.jet.codegen.JetTypeMapper;
+import org.jetbrains.jet.codegen.OwnerKind;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+
+import static org.jetbrains.jet.codegen.context.CodegenBinding.CLOSURE;
+
+/**
+ * @author alex.tkachman
+*/
+class AnonymousClassContext extends CodegenContext {
+    public AnonymousClassContext(
+            JetTypeMapper typeMapper,
+            ClassDescriptor contextDescriptor,
+            OwnerKind contextKind,
+            CodegenContext parentContext,
+            LocalLookup localLookup
+    ) {
+        //noinspection SuspiciousMethodCalls
+        super(contextDescriptor, contextKind, parentContext, (MutableClosure) typeMapper.getBindingContext().get(CLOSURE,
+                                                                                                                 contextDescriptor),
+              contextDescriptor,
+              localLookup);
+        initOuterExpression(typeMapper, contextDescriptor);
+    }
+
+    @Override
+    public boolean isStatic() {
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return "Anonymous: " + getThisDescriptor();
+    }
+}

compiler/backend/src/org/jetbrains/jet/codegen/context/ClassContext.java

@@ -0,0 +1,48 @@
+/*
+ * 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.context;
+
+import org.jetbrains.jet.codegen.JetTypeMapper;
+import org.jetbrains.jet.codegen.OwnerKind;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+
+import static org.jetbrains.jet.codegen.context.CodegenBinding.CLOSURE;
+
+/**
+ * @author alex.tkachman
+*/
+public class ClassContext extends CodegenContext {
+    public ClassContext(
+            JetTypeMapper typeMapper,
+            ClassDescriptor contextDescriptor,
+            OwnerKind contextKind,
+            CodegenContext parentContext,
+            LocalLookup localLookup
+    ) {
+        //noinspection SuspiciousMethodCalls
+        super(contextDescriptor, contextKind, parentContext, (MutableClosure) typeMapper.getBindingContext().get(CLOSURE,
+                                                                                                                 contextDescriptor),
+              contextDescriptor,
+              localLookup);
+        initOuterExpression(typeMapper, contextDescriptor);
+    }
+
+    @Override
+    public boolean isStatic() {
+        return false;
+    }
+}

compiler/backend/src/org/jetbrains/jet/codegen/context/ClosureContext.java

@@ -0,0 +1,64 @@
+/*
+ * 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.context;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.codegen.JetTypeMapper;
+import org.jetbrains.jet.codegen.OwnerKind;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+
+import static org.jetbrains.jet.codegen.context.CodegenBinding.CLOSURE;
+
+/**
+ * @author alex.tkachman
+*/
+class ClosureContext extends ReceiverContext {
+    private final ClassDescriptor classDescriptor;
+
+    public ClosureContext(
+            JetTypeMapper typeMapper,
+            FunctionDescriptor contextDescriptor,
+            ClassDescriptor classDescriptor,
+            CodegenContext parentContext,
+            LocalLookup localLookup
+    ) {
+        //noinspection SuspiciousMethodCalls
+        super(contextDescriptor, OwnerKind.IMPLEMENTATION, parentContext,
+              (MutableClosure) typeMapper.getBindingContext().get(CLOSURE, classDescriptor), classDescriptor, localLookup);
+        this.classDescriptor = classDescriptor;
+
+        initOuterExpression(typeMapper, classDescriptor);
+    }
+
+    @NotNull
+    @Override
+    public DeclarationDescriptor getContextDescriptor() {
+        return classDescriptor;
+    }
+
+    @Override
+    public boolean isStatic() {
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return "Closure: " + classDescriptor;
+    }
+}

compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java

@@ -22,17 +22,13 @@ import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.*;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 import static org.jetbrains.jet.codegen.AsmTypeConstants.*;
 import static org.jetbrains.jet.codegen.context.CodegenBinding.CLASS_FOR_FUNCTION;
-import static org.jetbrains.jet.codegen.context.CodegenBinding.CLOSURE;
 import static org.jetbrains.jet.codegen.context.CodegenBinding.FQN;
 
 /*
@@ -41,19 +37,8 @@ import static org.jetbrains.jet.codegen.context.CodegenBinding.FQN;
  */
 public abstract class CodegenContext {
 
-    public static final CodegenContext STATIC =
-            new CodegenContext(new FakeDescriptorForStaticContext(), OwnerKind.NAMESPACE, null, null, null, null) {
-                @Override
-                public boolean isStatic() {
-                    return true;
-                }
+    public static final CodegenContext STATIC = new RootContext();
 
-                @Override
-                public String toString() {
-                    return "ROOT";
-                }
-            };
-    private static final StackValue local1 = StackValue.local(1, OBJECT_TYPE);
     @NotNull
     private final DeclarationDescriptor contextDescriptor;
 
@@ -298,255 +283,4 @@ public abstract class CodegenContext {
     public Map<DeclarationDescriptor, DeclarationDescriptor> getAccessors() {
         return accessors == null ? Collections.<DeclarationDescriptor, DeclarationDescriptor>emptyMap() : accessors;
     }
-
-    private static class FakeDescriptorForStaticContext implements DeclarationDescriptor {
-
-        @NotNull
-        @Override
-        public DeclarationDescriptor getOriginal() {
-            throw new IllegalStateException();
-        }
-
-        @Override
-        public DeclarationDescriptor getContainingDeclaration() {
-            throw new IllegalStateException();
-        }
-
-        @Override
-        public DeclarationDescriptor substitute(TypeSubstitutor substitutor) {
-            throw new IllegalStateException();
-        }
-
-        @Override
-        public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
-            throw new IllegalStateException();
-        }
-
-        @Override
-        public void acceptVoid(DeclarationDescriptorVisitor<Void, Void> visitor) {
-            throw new IllegalStateException();
-        }
-
-        @Override
-        public List<AnnotationDescriptor> getAnnotations() {
-            throw new IllegalStateException();
-        }
-
-        @NotNull
-        @Override
-        public Name getName() {
-            throw new IllegalStateException();
-        }
-    }
-
-    private abstract static class ReceiverContext extends CodegenContext {
-        final CallableDescriptor receiverDescriptor;
-
-        public ReceiverContext(
-                CallableDescriptor contextDescriptor,
-                OwnerKind contextKind,
-                CodegenContext parentContext,
-                @Nullable MutableClosure closure,
-                ClassDescriptor thisDescriptor,
-                @Nullable LocalLookup localLookup
-        ) {
-            super(contextDescriptor, contextKind, parentContext, closure, thisDescriptor, localLookup);
-            receiverDescriptor = contextDescriptor.getReceiverParameter().exists() ? contextDescriptor : null;
-        }
-
-        @Override
-        public CallableDescriptor getReceiverDescriptor() {
-            return receiverDescriptor;
-        }
-    }
-
-    public static class MethodContext extends ReceiverContext {
-        public MethodContext(
-                @NotNull FunctionDescriptor contextType,
-                OwnerKind contextKind,
-                CodegenContext parentContext
-        ) {
-            super(contextType instanceof PropertyAccessorDescriptor
-                  ? ((PropertyAccessorDescriptor) contextType).getCorrespondingProperty()
-                  : contextType, contextKind, parentContext, null,
-                  parentContext.hasThisDescriptor() ? parentContext.getThisDescriptor() : null, null);
-        }
-
-        @Override
-        public StackValue lookupInContext(DeclarationDescriptor d, @Nullable StackValue result, GenerationState state, boolean ignoreNoOuter) {
-            if (getContextDescriptor() == d) {
-                return StackValue.local(0, AsmTypeConstants.OBJECT_TYPE);
-            }
-
-            //noinspection ConstantConditions
-            return getParentContext().lookupInContext(d, result, state, ignoreNoOuter);
-        }
-
-        @Override
-        public boolean isStatic() {
-            //noinspection ConstantConditions
-            return getParentContext().isStatic();
-        }
-
-        @Override
-        public StackValue getOuterExpression(StackValue prefix, boolean ignoreNoOuter) {
-            //noinspection ConstantConditions
-            return getParentContext().getOuterExpression(prefix, false);
-        }
-
-        @Override
-        public String toString() {
-            return "Method: " + getContextDescriptor();
-        }
-    }
-
-    public static class ConstructorContext extends MethodContext {
-        public ConstructorContext(
-                ConstructorDescriptor contextDescriptor,
-                OwnerKind kind,
-                CodegenContext parent
-        ) {
-            super(contextDescriptor, kind, parent);
-
-            final ClassDescriptor type = getEnclosingClass();
-            outerExpression = type != null ? local1 : null;
-        }
-
-        @Override
-        public StackValue getOuterExpression(StackValue prefix, boolean ignoreNoOuter) {
-            return outerExpression;
-        }
-
-        @Override
-        public String toString() {
-            return "Constructor: " + getContextDescriptor().getName();
-        }
-    }
-
-    public static class ScriptContext extends CodegenContext {
-        @NotNull
-        private final ScriptDescriptor scriptDescriptor;
-
-        public ScriptContext(
-                @NotNull ScriptDescriptor scriptDescriptor,
-                @NotNull ClassDescriptor contextDescriptor,
-                @NotNull OwnerKind contextKind,
-                @Nullable CodegenContext parentContext,
-                @Nullable MutableClosure closure
-        ) {
-            super(contextDescriptor, contextKind, parentContext, closure, contextDescriptor, null);
-
-            this.scriptDescriptor = scriptDescriptor;
-        }
-
-        @NotNull
-        public ScriptDescriptor getScriptDescriptor() {
-            return scriptDescriptor;
-        }
-
-        @Override
-        public boolean isStatic() {
-            return true;
-        }
-    }
-
-    public static class ClassContext extends CodegenContext {
-        public ClassContext(
-                JetTypeMapper typeMapper,
-                ClassDescriptor contextDescriptor,
-                OwnerKind contextKind,
-                CodegenContext parentContext,
-                LocalLookup localLookup
-        ) {
-            //noinspection SuspiciousMethodCalls
-            super(contextDescriptor, contextKind, parentContext, (MutableClosure) typeMapper.getBindingContext().get(CLOSURE,
-                                                                                                                     contextDescriptor),
-                  contextDescriptor,
-                  localLookup);
-            initOuterExpression(typeMapper, contextDescriptor);
-        }
-
-        @Override
-        public boolean isStatic() {
-            return false;
-        }
-    }
-
-    private static class AnonymousClassContext extends CodegenContext {
-        public AnonymousClassContext(
-                JetTypeMapper typeMapper,
-                ClassDescriptor contextDescriptor,
-                OwnerKind contextKind,
-                CodegenContext parentContext,
-                LocalLookup localLookup
-        ) {
-            //noinspection SuspiciousMethodCalls
-            super(contextDescriptor, contextKind, parentContext, (MutableClosure) typeMapper.getBindingContext().get(CLOSURE,
-                                                                                                                     contextDescriptor),
-                  contextDescriptor,
-                  localLookup);
-            initOuterExpression(typeMapper, contextDescriptor);
-        }
-
-        @Override
-        public boolean isStatic() {
-            return false;
-        }
-
-        @Override
-        public String toString() {
-            return "Anonymous: " + getThisDescriptor();
-        }
-    }
-
-    private static class ClosureContext extends ReceiverContext {
-        private final ClassDescriptor classDescriptor;
-
-        public ClosureContext(
-                JetTypeMapper typeMapper,
-                FunctionDescriptor contextDescriptor,
-                ClassDescriptor classDescriptor,
-                CodegenContext parentContext,
-                LocalLookup localLookup
-        ) {
-            //noinspection SuspiciousMethodCalls
-            super(contextDescriptor, OwnerKind.IMPLEMENTATION, parentContext,
-                  (MutableClosure) typeMapper.getBindingContext().get(CLOSURE, classDescriptor), classDescriptor, localLookup);
-            this.classDescriptor = classDescriptor;
-
-            initOuterExpression(typeMapper, classDescriptor);
-        }
-
-        @NotNull
-        @Override
-        public DeclarationDescriptor getContextDescriptor() {
-            return classDescriptor;
-        }
-
-        @Override
-        public boolean isStatic() {
-            return false;
-        }
-
-        @Override
-        public String toString() {
-            return "Closure: " + classDescriptor;
-        }
-    }
-
-    public static class NamespaceContext extends CodegenContext {
-        public NamespaceContext(NamespaceDescriptor contextDescriptor, CodegenContext parent, OwnerKind kind) {
-            super(contextDescriptor, kind != null ? kind : OwnerKind.NAMESPACE, parent, null, null, null);
-        }
-
-        @Override
-        public boolean isStatic() {
-            return true;
-        }
-
-        @Override
-        public String toString() {
-            return "Namespace: " + getContextDescriptor().getName();
-        }
-    }
 }

compiler/backend/src/org/jetbrains/jet/codegen/context/ConstructorContext.java

@@ -0,0 +1,52 @@
+/*
+ * 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.context;
+
+import org.jetbrains.jet.codegen.OwnerKind;
+import org.jetbrains.jet.codegen.StackValue;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
+
+import static org.jetbrains.jet.codegen.AsmTypeConstants.OBJECT_TYPE;
+
+/**
+ * @author alex.tkachman
+*/
+public class ConstructorContext extends MethodContext {
+    private static final StackValue local1 = StackValue.local(1, OBJECT_TYPE);
+
+    public ConstructorContext(
+            ConstructorDescriptor contextDescriptor,
+            OwnerKind kind,
+            CodegenContext parent
+    ) {
+        super(contextDescriptor, kind, parent);
+
+        final ClassDescriptor type = getEnclosingClass();
+        outerExpression = type != null ? local1 : null;
+    }
+
+    @Override
+    public StackValue getOuterExpression(StackValue prefix, boolean ignoreNoOuter) {
+        return outerExpression;
+    }
+
+    @Override
+    public String toString() {
+        return "Constructor: " + getContextDescriptor().getName();
+    }
+}

compiler/backend/src/org/jetbrains/jet/codegen/context/MethodContext.java

@@ -0,0 +1,70 @@
+/*
+ * 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.context;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.codegen.AsmTypeConstants;
+import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.OwnerKind;
+import org.jetbrains.jet.codegen.StackValue;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.PropertyAccessorDescriptor;
+
+/**
+ * @author alex.tkachman
+*/
+public class MethodContext extends ReceiverContext {
+    public MethodContext(
+            @NotNull FunctionDescriptor contextType,
+            OwnerKind contextKind,
+            CodegenContext parentContext
+    ) {
+        super(contextType instanceof PropertyAccessorDescriptor
+              ? ((PropertyAccessorDescriptor) contextType).getCorrespondingProperty()
+              : contextType, contextKind, parentContext, null,
+              parentContext.hasThisDescriptor() ? parentContext.getThisDescriptor() : null, null);
+    }
+
+    @Override
+    public StackValue lookupInContext(DeclarationDescriptor d, @Nullable StackValue result, GenerationState state, boolean ignoreNoOuter) {
+        if (getContextDescriptor() == d) {
+            return StackValue.local(0, AsmTypeConstants.OBJECT_TYPE);
+        }
+
+        //noinspection ConstantConditions
+        return getParentContext().lookupInContext(d, result, state, ignoreNoOuter);
+    }
+
+    @Override
+    public boolean isStatic() {
+        //noinspection ConstantConditions
+        return getParentContext().isStatic();
+    }
+
+    @Override
+    public StackValue getOuterExpression(StackValue prefix, boolean ignoreNoOuter) {
+        //noinspection ConstantConditions
+        return getParentContext().getOuterExpression(prefix, false);
+    }
+
+    @Override
+    public String toString() {
+        return "Method: " + getContextDescriptor();
+    }
+}

compiler/backend/src/org/jetbrains/jet/codegen/context/NamespaceContext.java

@@ -0,0 +1,39 @@
+/*
+ * 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.context;
+
+import org.jetbrains.jet.codegen.OwnerKind;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+
+/**
+ * @author alex.tkachman
+*/
+public class NamespaceContext extends CodegenContext {
+    public NamespaceContext(NamespaceDescriptor contextDescriptor, CodegenContext parent, OwnerKind kind) {
+        super(contextDescriptor, kind != null ? kind : OwnerKind.NAMESPACE, parent, null, null, null);
+    }
+
+    @Override
+    public boolean isStatic() {
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "Namespace: " + getContextDescriptor().getName();
+    }
+}

compiler/backend/src/org/jetbrains/jet/codegen/context/ReceiverContext.java

@@ -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.codegen.context;
+
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.codegen.OwnerKind;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+
+/**
+ * @author alex.tkachman
+*/
+abstract class ReceiverContext extends CodegenContext {
+    final CallableDescriptor receiverDescriptor;
+
+    public ReceiverContext(
+            CallableDescriptor contextDescriptor,
+            OwnerKind contextKind,
+            CodegenContext parentContext,
+            @Nullable MutableClosure closure,
+            ClassDescriptor thisDescriptor,
+            @Nullable LocalLookup localLookup
+    ) {
+        super(contextDescriptor, contextKind, parentContext, closure, thisDescriptor, localLookup);
+        receiverDescriptor = contextDescriptor.getReceiverParameter().exists() ? contextDescriptor : null;
+    }
+
+    @Override
+    public CallableDescriptor getReceiverDescriptor() {
+        return receiverDescriptor;
+    }
+}

compiler/backend/src/org/jetbrains/jet/codegen/context/RootContext.java

@@ -0,0 +1,85 @@
+/*
+ * 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.context;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.codegen.OwnerKind;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
+
+import java.util.List;
+
+/**
+ * @author alex.tkachman
+*/
+class RootContext extends CodegenContext {
+    public RootContext() {
+        super(new FakeDescriptor(), OwnerKind.NAMESPACE, null, null, null, null);
+    }
+
+    @Override
+    public boolean isStatic() {
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "ROOT";
+    }
+
+    private static class FakeDescriptor implements DeclarationDescriptor {
+        @NotNull
+        @Override
+        public DeclarationDescriptor getOriginal() {
+            throw new IllegalStateException();
+        }
+
+        @Override
+        public DeclarationDescriptor getContainingDeclaration() {
+            throw new IllegalStateException();
+        }
+
+        @Override
+        public DeclarationDescriptor substitute(TypeSubstitutor substitutor) {
+            throw new IllegalStateException();
+        }
+
+        @Override
+        public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
+            throw new IllegalStateException();
+        }
+
+        @Override
+        public void acceptVoid(DeclarationDescriptorVisitor<Void, Void> visitor) {
+            throw new IllegalStateException();
+        }
+
+        @Override
+        public List<AnnotationDescriptor> getAnnotations() {
+            throw new IllegalStateException();
+        }
+
+        @NotNull
+        @Override
+        public Name getName() {
+            throw new IllegalStateException();
+        }
+    }
+}

compiler/backend/src/org/jetbrains/jet/codegen/context/ScriptContext.java

@@ -0,0 +1,53 @@
+/*
+ * 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.context;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.codegen.OwnerKind;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
+
+/**
+ * @author alex.tkachman
+*/
+public class ScriptContext extends CodegenContext {
+    @NotNull
+    private final ScriptDescriptor scriptDescriptor;
+
+    public ScriptContext(
+            @NotNull ScriptDescriptor scriptDescriptor,
+            @NotNull ClassDescriptor contextDescriptor,
+            @NotNull OwnerKind contextKind,
+            @Nullable CodegenContext parentContext,
+            @Nullable MutableClosure closure
+    ) {
+        super(contextDescriptor, contextKind, parentContext, closure, contextDescriptor, null);
+
+        this.scriptDescriptor = scriptDescriptor;
+    }
+
+    @NotNull
+    public ScriptDescriptor getScriptDescriptor() {
+        return scriptDescriptor;
+    }
+
+    @Override
+    public boolean isStatic() {
+        return true;
+    }
+}