Work on namespaces in progress.

translator/src/org/jetbrains/k2js/translate/AbstractInitializerVisitor.java

@@ -0,0 +1,74 @@
+package org.jetbrains.k2js.translate;
+
+import com.google.dart.compiler.backend.js.ast.JsExpression;
+import com.google.dart.compiler.backend.js.ast.JsFunction;
+import com.google.dart.compiler.backend.js.ast.JsScope;
+import com.google.dart.compiler.backend.js.ast.JsStatement;
+import com.google.dart.compiler.util.AstUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetClassInitializer;
+import org.jetbrains.jet.lang.psi.JetDeclaration;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.psi.JetProperty;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author Talanov Pavel
+ */
+public abstract class AbstractInitializerVisitor extends TranslatorVisitor<List<JsStatement>> {
+
+    @NotNull
+    protected final JsScope initializerMethodScope;
+
+    @NotNull
+    protected final TranslationContext initializerMethodContext;
+
+    protected AbstractInitializerVisitor(@NotNull TranslationContext enclosingContext, @NotNull JsScope newScope) {
+        this.initializerMethodContext = enclosingContext.newEnclosingScope(newScope);
+        this.initializerMethodScope = newScope;
+    }
+
+    @NotNull
+    abstract protected JsFunction generate();
+
+    @Override
+    @NotNull
+    public List<JsStatement> visitProperty(@NotNull JetProperty expression, @NotNull TranslationContext context) {
+        JetExpression initializer = expression.getInitializer();
+        if (initializer == null) {
+            return new ArrayList<JsStatement>();
+        }
+        return Arrays.asList(translateInitializer(expression, context, initializer));
+    }
+
+    @NotNull
+    private JsStatement translateInitializer(@NotNull JetProperty property, @NotNull TranslationContext context,
+                                             @NotNull JetExpression initializer) {
+        JsExpression initExpression = Translation.translateAsExpression(initializer, context);
+        return assignmentToBackingField(property, initExpression, context);
+    }
+
+    @NotNull
+    JsStatement assignmentToBackingField(@NotNull JetProperty property, @NotNull JsExpression initExpression,
+                                         @NotNull TranslationContext context) {
+
+        return AstUtil.newAssignmentStatement(backingFieldReference(property, context), initExpression);
+    }
+
+    @Override
+    @NotNull
+    public List<JsStatement> visitAnonymousInitializer(@NotNull JetClassInitializer initializer,
+                                                       @NotNull TranslationContext context) {
+        return Arrays.asList(Translation.translateAsStatement(initializer.getBody(), context));
+    }
+
+    @Override
+    @NotNull
+    // Not interested in other types of declarations, they do not contain initializers.
+    public List<JsStatement> visitDeclaration(@NotNull JetDeclaration expression, @NotNull TranslationContext context) {
+        return new ArrayList<JsStatement>();
+    }
+}

translator/src/org/jetbrains/k2js/translate/ClassDeclarationTranslator.java

@@ -0,0 +1,102 @@
+package org.jetbrains.k2js.translate;
+
+import com.google.dart.compiler.backend.js.ast.*;
+import com.google.dart.compiler.util.AstUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.psi.JetClass;
+import org.jetbrains.jet.lang.psi.JetDeclaration;
+import org.jetbrains.jet.lang.psi.JetNamespace;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Talanov Pavel
+ */
+//TODO: implement
+public final class ClassDeclarationTranslator extends AbstractTranslator {
+
+    @NotNull
+    private final JetNamespace namespace;
+    @NotNull
+    private final Map<JsName, JsName> localToGlobalClassName;
+    @NotNull
+    private final JsScope dummyFunctionScope;
+    @Nullable
+    private JsName declarationsObject = null;
+    @Nullable
+    private JsStatement declarationsStatement = null;
+
+    public ClassDeclarationTranslator(@NotNull TranslationContext context, @NotNull JetNamespace namespace) {
+        super(context);
+        this.namespace = namespace;
+        this.localToGlobalClassName = new HashMap<JsName, JsName>();
+        this.dummyFunctionScope = new JsScope(translationContext().enclosingScope(), "class declaration function");
+    }
+
+    public void generateDeclarations() {
+        //TODO: hardcoded string
+        declarationsObject = translationContext().enclosingScope().declareName("classes");
+        declarationsStatement =
+                AstUtil.newAssignmentStatement(declarationsObject.makeRef(), generateDummyFunctionInvocation());
+    }
+
+    @NotNull
+    public JsName getDeclarationsObjectName() {
+        assert declarationsObject != null : "Should run generateDeclarations first";
+        return declarationsObject;
+    }
+
+    @NotNull
+    public JsStatement getDeclarationsStatement() {
+        assert declarationsStatement != null : "Should run generateDeclarations first";
+        return declarationsStatement;
+    }
+
+    @NotNull
+    private JsInvocation generateDummyFunctionInvocation() {
+        JsFunction dummyFunction = JsFunction.getAnonymousFunctionWithScope(dummyFunctionScope);
+        List<JsStatement> classDeclarations = getClassDeclarationStatements();
+        classDeclarations.add(new JsReturn(generateReturnedObjectLiteral()));
+        dummyFunction.setBody(AstUtil.newBlock(classDeclarations));
+        return AstUtil.newInvocation(dummyFunction);
+    }
+
+    @NotNull
+    private JsObjectLiteral generateReturnedObjectLiteral() {
+        JsObjectLiteral returnedValueLiteral = new JsObjectLiteral();
+        for (JsName localName : localToGlobalClassName.keySet()) {
+            returnedValueLiteral.getPropertyInitializers().add(classEntry(localName));
+        }
+        return returnedValueLiteral;
+    }
+
+    @NotNull
+    private JsPropertyInitializer classEntry(@NotNull JsName localName) {
+        return new JsPropertyInitializer(localToGlobalClassName.get(localName).makeRef(), localName.makeRef());
+    }
+
+    @NotNull
+    private List<JsStatement> getClassDeclarationStatements() {
+        List<JsStatement> classDeclarations = new ArrayList<JsStatement>();
+        for (JetDeclaration declaration : namespace.getDeclarations()) {
+            if (declaration instanceof JetClass) {
+                classDeclarations.add(generateDeclaration((JetClass) declaration));
+            }
+        }
+        return classDeclarations;
+    }
+
+    @NotNull
+    private JsStatement generateDeclaration(@NotNull JetClass declaration) {
+        JsName globalClassName = translationContext().getNameForElement(declaration);
+        JsName localClassName = dummyFunctionScope.declareName(globalClassName.getIdent());
+        localToGlobalClassName.put(localClassName, globalClassName);
+        JsInvocation classDeclarationExpression =
+                Translation.classTranslator(translationContext()).translateClass(declaration);
+        return AstUtil.newVar(localClassName, classDeclarationExpression);
+    }
+}

translator/src/org/jetbrains/k2js/translate/ClassInitializerVisitor.java

@@ -6,34 +6,25 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.*;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
 /**
  * @author Talanov Pavel
- *         <p/>
- *         This visitor collects all initializers from a given class into JsFunction object.
- *         Note: we do use visitor pattern to preserve the order in which initializers are executed.
  */
-public class InitializerVisitor extends TranslatorVisitor<List<JsStatement>> {
+public final class ClassInitializerVisitor extends AbstractInitializerVisitor {
 
-    @NotNull
-    private final JsScope initializerMethodScope;
     @NotNull
     private final JetClass classDeclaration;
-    @NotNull
-    private final TranslationContext initializerMethodContext;
 
-    public InitializerVisitor(@NotNull JetClass classDeclaration, @NotNull TranslationContext context) {
+    public ClassInitializerVisitor(@NotNull JetClass classDeclaration, @NotNull TranslationContext context) {
-        this.initializerMethodScope = new JsScope(context.getScopeForElement(classDeclaration),
+        super(context, new JsScope(context.getScopeForElement(classDeclaration),
-                "initializer " + classDeclaration.getName());
+                "initializer " + classDeclaration.getName()));
         this.classDeclaration = classDeclaration;
-        this.initializerMethodContext = context.newEnclosingScope(initializerMethodScope);
-
     }
 
+    @Override
     @NotNull
-    public JsFunction generateInitializeMethod() {
+    public JsFunction generate() {
         JsFunction result = JsFunction.getAnonymousFunctionWithScope(initializerMethodScope);
         result.setParameters(translatePrimaryConstructorParameters(classDeclaration));
         result.setBody(generateInitializerMethodBody(classDeclaration, initializerMethodContext));
@@ -102,48 +93,4 @@ public class InitializerVisitor extends TranslatorVisitor<List<JsStatement>> {
         }
         return result;
     }
-
-    @Override
-    @NotNull
-    public List<JsStatement> visitProperty(@NotNull JetProperty expression, @NotNull TranslationContext context) {
-        JetExpression initializer = expression.getInitializer();
-        declareBackingFieldName(expression);
-        if (initializer == null) {
-            return new ArrayList<JsStatement>();
-        }
-        return Arrays.asList(translateInitializer(expression, context, initializer));
-    }
-
-    private void declareBackingFieldName(@NotNull JetProperty property) {
-        initializerMethodScope.declareName(Namer.getKotlinBackingFieldName(property.getName()));
-    }
-
-    @NotNull
-    private JsStatement translateInitializer(@NotNull JetProperty property, @NotNull TranslationContext context,
-                                             @NotNull JetExpression initializer) {
-        JsExpression initExpression = Translation.translateAsExpression(initializer, context);
-        return assignmentToBackingField(property, initExpression, context);
-    }
-
-    @NotNull
-    JsStatement assignmentToBackingField(@NotNull JetProperty property, @NotNull JsExpression initExpression,
-                                         @NotNull TranslationContext context) {
-
-        return AstUtil.newAssignmentStatement(backingFieldReference(property, context), initExpression);
-    }
-
-    @Override
-    @NotNull
-    public List<JsStatement> visitAnonymousInitializer(@NotNull JetClassInitializer initializer,
-                                                       @NotNull TranslationContext context) {
-        return Arrays.asList(Translation.translateAsStatement(initializer.getBody(), context));
-    }
-
-    @Override
-    @NotNull
-    // Not interested in other types of declarations, they do not contain initializers.
-    public List<JsStatement> visitDeclaration(@NotNull JetDeclaration expression, @NotNull TranslationContext context) {
-        return new ArrayList<JsStatement>();
-    }
-
 }

translator/src/org/jetbrains/k2js/translate/ClassTranslator.java

@@ -1,6 +1,9 @@
 package org.jetbrains.k2js.translate;
 
-import com.google.dart.compiler.backend.js.ast.*;
+import com.google.dart.compiler.backend.js.ast.JsInvocation;
+import com.google.dart.compiler.backend.js.ast.JsNameRef;
+import com.google.dart.compiler.backend.js.ast.JsObjectLiteral;
+import com.google.dart.compiler.backend.js.ast.JsPropertyInitializer;
 import com.google.dart.compiler.util.AstUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -19,7 +22,7 @@ import java.util.List;
 public final class ClassTranslator extends AbstractTranslator {
 
     @NotNull
-    private final ClassBodyVisitor classBodyVisitor = new ClassBodyVisitor();
+    private final DeclarationBodyVisitor declarationBodyVisitor = new DeclarationBodyVisitor();
 
     @NotNull
     public static ClassTranslator newInstance(@NotNull TranslationContext context) {
@@ -31,11 +34,11 @@ public final class ClassTranslator extends AbstractTranslator {
     }
 
     @NotNull
-    public JsStatement translateClass(@NotNull JetClass jetClassDeclaration) {
+    public JsInvocation translateClass(@NotNull JetClass jetClassDeclaration) {
         JsInvocation jsClassDeclaration = classCreateMethodInvocation(jetClassDeclaration);
         addSuperclassReferences(jetClassDeclaration, jsClassDeclaration);
         addClassOwnDeclarations(jetClassDeclaration, jsClassDeclaration);
-        return classDeclarationStatement(jetClassDeclaration, jsClassDeclaration);
+        return jsClassDeclaration;
     }
 
     @NotNull
@@ -47,18 +50,13 @@ public final class ClassTranslator extends AbstractTranslator {
         }
     }
 
-    @NotNull
+    //TODO
-    private JsStatement classDeclarationStatement(@NotNull JetClass classDeclaration,
+//    @NotNull
-                                                  @NotNull JsInvocation jsClassDeclaration) {
+//    private JsStatement classDeclarationStatement(@NotNull JetClass classDeclaration,
-        return AstUtil.newAssignmentStatement
+//                                                  @NotNull JsInvocation jsClassDeclaration) {
-                (namespaceQualifiedClassNameReference(classDeclaration), jsClassDeclaration);
+//        JsNameRef unqualifiedClassNameReference = translationContext().getNameForElement(classDeclaration).makeRef();
-    }
+//        return AstUtil.newAssignmentStatement(unqualifiedClassNameReference, jsClassDeclaration);
-
+//    }
-    @NotNull
-    private JsNameRef namespaceQualifiedClassNameReference(@NotNull JetClass classDeclaration) {
-        return translationContext().getNamespaceQualifiedReference
-                (translationContext().getNameForElement(classDeclaration));
-    }
 
     private void addClassOwnDeclarations(@NotNull JetClass classDeclaration,
                                          @NotNull JsInvocation jsClassDeclaration) {
@@ -119,27 +117,10 @@ public final class ClassTranslator extends AbstractTranslator {
     private JsObjectLiteral translateClassDeclarations(@NotNull JetClass classDeclaration) {
         List<JsPropertyInitializer> propertyList = new ArrayList<JsPropertyInitializer>();
         if (!classDeclaration.isTrait()) {
-            propertyList.add(generateInitializeMethod(classDeclaration));
+            propertyList.add(InitializerGenerator.generateInitializeMethod(classDeclaration, translationContext()));
         }
-        propertyList.addAll(classDeclaration.accept(classBodyVisitor,
+        propertyList.addAll(declarationBodyVisitor.traverseClass(classDeclaration,
                 translationContext().newClass(classDeclaration)));
         return new JsObjectLiteral(propertyList);
     }
-
-    // TODO: names are inconsistent
-    @NotNull
-    private JsPropertyInitializer generateInitializeMethod(@NotNull JetClass classDeclaration) {
-        JsPropertyInitializer initializer = new JsPropertyInitializer();
-        initializer.setLabelExpr(program().getStringLiteral(Namer.INITIALIZE_METHOD_NAME));
-        initializer.setValueExpr(generateInitializeMethodBody(classDeclaration));
-        return initializer;
-    }
-
-    @NotNull
-    private JsFunction generateInitializeMethodBody(@NotNull JetClass classDeclaration) {
-        InitializerVisitor initializerVisitor = new InitializerVisitor(classDeclaration,
-                translationContext().newClass(classDeclaration));
-        return initializerVisitor.generateInitializeMethod();
-    }
-
 }

translator/src/org/jetbrains/k2js/translate/DeclarationBodyVisitor.java

@@ -9,16 +9,18 @@ import org.jetbrains.jet.lang.psi.*;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 /**
  * @author Talanov Pavel
  */
-public final class ClassBodyVisitor extends TranslatorVisitor<List<JsPropertyInitializer>> {
+public final class DeclarationBodyVisitor extends TranslatorVisitor<List<JsPropertyInitializer>> {
+
 
-    @Override
     @NotNull
-    public List<JsPropertyInitializer> visitClass(@NotNull JetClass expression, @NotNull TranslationContext context) {
+    public List<JsPropertyInitializer> traverseClass(@NotNull JetClass expression,
+                                                     @NotNull TranslationContext context) {
         List<JsPropertyInitializer> properties = new ArrayList<JsPropertyInitializer>();
         for (JetDeclaration declaration : expression.getDeclarations()) {
             properties.addAll(declaration.accept(this, context));
@@ -26,13 +28,28 @@ public final class ClassBodyVisitor extends TranslatorVisitor<List<JsPropertyIni
         return properties;
     }
 
+    @NotNull
+    public List<JsPropertyInitializer> traverseNamespace(@NotNull JetNamespace expression,
+                                                         @NotNull TranslationContext context) {
+        List<JsPropertyInitializer> properties = new ArrayList<JsPropertyInitializer>();
+        for (JetDeclaration declaration : expression.getDeclarations()) {
+            properties.addAll(declaration.accept(this, context));
+        }
+        return properties;
+    }
+
+    //TODO
+    @Override
+    @NotNull
+    public List<JsPropertyInitializer> visitClass(@NotNull JetClass expression, @NotNull TranslationContext context) {
+        //return Arrays.asList(Translation.classTranslator(context).translateClass(expression));
+        return Collections.emptyList();
+    }
+
     @Override
     @NotNull
-    // method declaration
     public List<JsPropertyInitializer> visitNamedFunction(@NotNull JetNamedFunction expression, @NotNull TranslationContext context) {
-        List<JsPropertyInitializer> properties = new ArrayList<JsPropertyInitializer>();
+        return Arrays.asList(Translation.functionTranslator(context).translateAsMethod(expression));
-        properties.add(Translation.functionTranslator(context).translateAsMethod(expression));
-        return properties;
     }
 
     @Override
@@ -145,6 +162,6 @@ public final class ClassBodyVisitor extends TranslatorVisitor<List<JsPropertyIni
     public List<JsPropertyInitializer> visitAnonymousInitializer(@NotNull JetClassInitializer expression,
                                                                  @NotNull TranslationContext context) {
         // parsed it in initializer visitor => no additional actions are needed
-        return new ArrayList<JsPropertyInitializer>();
+        return Collections.emptyList();
     }
 }

translator/src/org/jetbrains/k2js/translate/GenerationState.java

@@ -26,8 +26,7 @@ public final class GenerationState {
         JetNamespace namespace = namespaces.get(0);
         NamespaceDescriptor descriptor = BindingUtils.getNamespaceDescriptor(bindingContext, namespace);
         Declarations declarations = Declarations.extractDeclarations(descriptor, result.getRootScope());
-        Translation.namespaceTranslator(TranslationContext.rootContext(result, bindingContext, declarations))
+        Translation.generateAst(result, bindingContext, declarations, namespace);
-                .generateAst(namespace);
         return result;
     }
 

translator/src/org/jetbrains/k2js/translate/InitializerGenerator.java

@@ -0,0 +1,52 @@
+package org.jetbrains.k2js.translate;
+
+import com.google.dart.compiler.backend.js.ast.JsFunction;
+import com.google.dart.compiler.backend.js.ast.JsPropertyInitializer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetClass;
+import org.jetbrains.jet.lang.psi.JetNamedDeclaration;
+import org.jetbrains.jet.lang.psi.JetNamespace;
+
+public class InitializerGenerator {
+
+    @NotNull
+    private final TranslationContext context;
+    @NotNull
+    private final JetNamedDeclaration declaration;
+
+    static public JsPropertyInitializer generateInitializeMethod(@NotNull JetNamedDeclaration declaration,
+                                                                 @NotNull TranslationContext context) {
+        return (new InitializerGenerator(context, declaration)).generateInitializeMethod();
+    }
+
+    private InitializerGenerator(@NotNull TranslationContext context, @NotNull JetNamedDeclaration declaration) {
+        this.context = context;
+        this.declaration = declaration;
+        assert (declaration instanceof JetClass) || (declaration instanceof JetNamespace) :
+                "Can create initializers for classes or namespaces only";
+    }
+
+    @NotNull
+    public JsPropertyInitializer generateInitializeMethod() {
+        JsPropertyInitializer initializer = new JsPropertyInitializer();
+        initializer.setLabelExpr(context.program().getStringLiteral(Namer.INITIALIZE_METHOD_NAME));
+        initializer.setValueExpr(generateInitializeFunction());
+        return initializer;
+    }
+
+    @NotNull
+    private JsFunction generateInitializeFunction() {
+        AbstractInitializerVisitor visitor;
+        if (declaration instanceof JetNamespace) {
+            JetNamespace namespaceDeclaration = (JetNamespace) declaration;
+            visitor = new NamespaceInitializerVisitor(namespaceDeclaration,
+                    context.newNamespace(namespaceDeclaration));
+        } else {
+            assert declaration instanceof JetClass;
+            JetClass classDeclaration = (JetClass) declaration;
+            visitor = new ClassInitializerVisitor(classDeclaration,
+                    context.newClass(classDeclaration));
+        }
+        return visitor.generate();
+    }
+}

translator/src/org/jetbrains/k2js/translate/Namer.java

@@ -71,6 +71,10 @@ public final class Namer {
         return AstUtil.newQualifiedNameRef("Trait.create");
     }
 
+    public static JsNameRef namespaceCreationMethodReference() {
+        return AstUtil.newQualifiedNameRef("Namespace.create");
+    }
+
     public static JsNameRef isOperationReference() {
         return AstUtil.newQualifiedNameRef("isType");
     }

translator/src/org/jetbrains/k2js/translate/NamespaceDeclarationTranslator.java

@@ -1,29 +0,0 @@
-package org.jetbrains.k2js.translate;
-
-import com.google.dart.compiler.backend.js.ast.JsStatement;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.JetDeclaration;
-
-/**
- * @author Talanov Pavel
- */
-public final class NamespaceDeclarationTranslator extends AbstractTranslator {
-
-    private NamespaceDeclarationVisitor visitor = new NamespaceDeclarationVisitor();
-
-    @NotNull
-    public static NamespaceDeclarationTranslator newInstance(@NotNull TranslationContext context) {
-        return new NamespaceDeclarationTranslator(context);
-    }
-
-    private NamespaceDeclarationTranslator(TranslationContext context) {
-        super(context);
-    }
-
-    @NotNull
-    JsStatement translateDeclaration(JetDeclaration declaration) {
-        return declaration.accept(visitor, translationContext());
-    }
-
-
-}

translator/src/org/jetbrains/k2js/translate/NamespaceDeclarationVisitor.java

@@ -1,47 +0,0 @@
-package org.jetbrains.k2js.translate;
-
-import com.google.dart.compiler.backend.js.ast.JsExpression;
-import com.google.dart.compiler.backend.js.ast.JsName;
-import com.google.dart.compiler.backend.js.ast.JsNameRef;
-import com.google.dart.compiler.backend.js.ast.JsStatement;
-import com.google.dart.compiler.util.AstUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.JetClass;
-import org.jetbrains.jet.lang.psi.JetNamedFunction;
-import org.jetbrains.jet.lang.psi.JetProperty;
-
-/**
- * @author Talanov Pavel
- */
-//TODO: rework the class
-public class NamespaceDeclarationVisitor extends TranslatorVisitor<JsStatement> {
-
-    @NotNull
-    @Override
-    //TODO method too long
-    public JsStatement visitProperty(@NotNull JetProperty expression, @NotNull TranslationContext context) {
-        JsName propertyName = context.declareLocalName(getPropertyName(expression));
-        JsNameRef jsPropertyNameReference = context.getNamespaceQualifiedReference(propertyName);
-        JsExpression jsInitExpression = translateInitializerForProperty(expression, context);
-        JsExpression result;
-        if (jsInitExpression != null) {
-            result = AstUtil.newAssignment(jsPropertyNameReference, jsInitExpression);
-        } else {
-            result = jsPropertyNameReference;
-        }
-        return AstUtil.convertToStatement(result);
-    }
-
-    @NotNull
-    @Override
-    public JsStatement visitClass(@NotNull JetClass expression, @NotNull TranslationContext context) {
-        return Translation.classTranslator(context).translateClass(expression);
-    }
-
-    @NotNull
-    @Override
-    public JsStatement visitNamedFunction(@NotNull JetNamedFunction expression, @NotNull TranslationContext context) {
-        return AstUtil.convertToStatement(Translation.functionTranslator(context).translateAsFunctionDeclaration(expression));
-    }
-
-}

translator/src/org/jetbrains/k2js/translate/NamespaceInitializerVisitor.java

@@ -0,0 +1,31 @@
+package org.jetbrains.k2js.translate;
+
+import com.google.dart.compiler.backend.js.ast.JsFunction;
+import com.google.dart.compiler.backend.js.ast.JsScope;
+import com.google.dart.compiler.util.AstUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetNamespace;
+
+/**
+ * @author Talanov Pavel
+ */
+public final class NamespaceInitializerVisitor extends AbstractInitializerVisitor {
+
+    @NotNull
+    private final JetNamespace namespace;
+
+    public NamespaceInitializerVisitor(@NotNull JetNamespace namespace, @NotNull TranslationContext context) {
+        super(context, new JsScope(context.getScopeForElement(namespace),
+                "initializer " + namespace.getName()));
+        this.namespace = namespace;
+    }
+
+    @Override
+    @NotNull
+    public JsFunction generate() {
+        JsFunction result = JsFunction.getAnonymousFunctionWithScope(initializerMethodScope);
+        result.setBody(AstUtil.newBlock(namespace.accept(this, initializerMethodContext)));
+        return result;
+    }
+
+}

translator/src/org/jetbrains/k2js/translate/NamespaceTranslator.java

@@ -3,7 +3,6 @@ package org.jetbrains.k2js.translate;
 import com.google.dart.compiler.backend.js.ast.*;
 import com.google.dart.compiler.util.AstUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetNamespace;
 
 import java.util.ArrayList;
@@ -23,50 +22,44 @@ public final class NamespaceTranslator extends AbstractTranslator {
         super(context);
     }
 
-    public JsProgram generateAst(@NotNull JetNamespace namespace) {
-        translate(namespace);
-        return program();
-    }
-
-    //TODO logic unclear
     @NotNull
-    public JsBlock translate(@NotNull JetNamespace namespace) {
+    public JsStatement translateNamespace(@NotNull JetNamespace namespace) {
-        // TODO support multiple namespaces
+        ClassDeclarationTranslator translator = new ClassDeclarationTranslator(translationContext(), namespace);
-        JsBlock block = program().getFragmentBlock(0);
+        translator.generateDeclarations();
-        JsName namespaceName = translationContext().enclosingScope().declareName(Namer.getNameForNamespace(namespace.getName()));
+        JsName declarationsObjectName = translator.getDeclarationsObjectName();
-        block.addStatement(namespaceInitStatement(namespaceName));
+        JsBlock result = new JsBlock();
-        TranslationContext newContext = translationContext().newNamespace(namespace);
+        JsInvocation namespaceDeclaration = namespaceCreateMethodInvocation(namespace);
-        JsFunction dummyFunction = JsFunction.getAnonymousFunctionWithScope
+        namespaceDeclaration.getArguments().add(declarationsObjectName.makeRef());
-                (translationContext().getScopeForElement(namespace));
+        addMemberDeclarations(namespace, namespaceDeclaration);
-        JsBlock namespaceDeclarations = translateDeclarations(namespace, newContext);
+        result.addStatement(translator.getDeclarationsStatement());
-        JsInvocation namespaceExpression = newNamespace(namespaceName, namespaceDeclarations, dummyFunction);
+        result.addStatement(namespaceDeclarationStatement(namespace, namespaceDeclaration));
-        block.addStatement(AstUtil.convertToStatement(namespaceExpression));
+        return result;
-        return block;
     }
 
     @NotNull
-    private JsBlock translateDeclarations(@NotNull JetNamespace namespace, @NotNull TranslationContext newContext) {
+    private JsInvocation namespaceCreateMethodInvocation(@NotNull JetNamespace namespace) {
-        NamespaceDeclarationTranslator namespaceDeclarationTranslator = Translation.declarationTranslator(newContext);
+        return AstUtil.newInvocation(Namer.namespaceCreationMethodReference());
-        JsBlock namespaceDeclarations = new JsBlock();
-        for (JetDeclaration declaration : namespace.getDeclarations()) {
-            namespaceDeclarations.addStatement(namespaceDeclarationTranslator.translateDeclaration(declaration));
-        }
-        return namespaceDeclarations;
     }
 
     @NotNull
-    private JsStatement namespaceInitStatement(@NotNull JsName namespaceName) {
+    private JsStatement namespaceDeclarationStatement(@NotNull JetNamespace namespace,
-        return AstUtil.newAssignmentStatement(namespaceName.makeRef(), new JsObjectLiteral());
+                                                      @NotNull JsInvocation namespaceDeclaration) {
+        return AstUtil.newAssignmentStatement
+                (translationContext().getNameForElement(namespace).makeRef(), namespaceDeclaration);
+    }
+
+    private void addMemberDeclarations(@NotNull JetNamespace namespace,
+                                       @NotNull JsInvocation jsNamespace) {
+        JsObjectLiteral jsClassDescription = translateNamespaceMemberDeclarations(namespace);
+        jsNamespace.getArguments().add(jsClassDescription);
     }
 
     @NotNull
-    private JsInvocation newNamespace(@NotNull JsName name, @NotNull JsBlock namespaceDeclarations,
+    private JsObjectLiteral translateNamespaceMemberDeclarations(@NotNull JetNamespace namespace) {
-                                      @NotNull JsFunction dummyFunction) {
+        List<JsPropertyInitializer> propertyList = new ArrayList<JsPropertyInitializer>();
-        List<JsParameter> params = new ArrayList<JsParameter>();
+        propertyList.add(InitializerGenerator.generateInitializeMethod(namespace, translationContext()));
-        params.add(new JsParameter(name));
+        propertyList.addAll(new DeclarationBodyVisitor().traverseNamespace(namespace,
-        dummyFunction.setParameters(params);
+                translationContext().newNamespace(namespace)));
-        JsExpression invocationParam = name.makeRef();
+        return new JsObjectLiteral(propertyList);
-        dummyFunction.setBody(namespaceDeclarations);
-        return AstUtil.newInvocation(dummyFunction, invocationParam);
     }
 }

translator/src/org/jetbrains/k2js/translate/ReferenceProvider.java

@@ -29,12 +29,13 @@ public final class ReferenceProvider {
         this.requiresNamespaceQualifier = requiresNamespaceQualifier();
     }
 
+    //TODO
     @NotNull
     public JsNameRef generateCorrectReference() {
-        if (requiresNamespaceQualifier) {
+        if (requiresThisQualifier) {
-            return context.getNamespaceQualifiedReference(referencedName);
-        } else if (requiresThisQualifier) {
             return AstUtil.thisQualifiedReference(referencedName);
+        } else if (requiresNamespaceQualifier) {
+            return context.getNamespaceQualifiedReference(referencedName);
         }
         return referencedName.makeRef();
     }
@@ -45,8 +46,9 @@ public final class ReferenceProvider {
 
     private boolean requiresThisQualifier(@NotNull JetSimpleNameExpression expression) {
         JsName name = context.enclosingScope().findExistingName(referencedName.getIdent());
+        boolean isNamespaceMember = requiresNamespaceQualifier;
         boolean isClassMember = context.classScope().ownsName(name);
         boolean isBackingFieldAccess = expression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER;
-        return isClassMember || isBackingFieldAccess;
+        return (isNamespaceMember && !isClassMember) || isClassMember || isBackingFieldAccess;
     }
 }

translator/src/org/jetbrains/k2js/translate/Translation.java

@@ -1,12 +1,13 @@
 package org.jetbrains.k2js.translate;
 
-import com.google.dart.compiler.backend.js.ast.JsExpression;
+import com.google.dart.compiler.backend.js.ast.*;
-import com.google.dart.compiler.backend.js.ast.JsNode;
-import com.google.dart.compiler.backend.js.ast.JsStatement;
 import com.google.dart.compiler.util.AstUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.psi.JetNamespace;
 import org.jetbrains.jet.lang.psi.JetWhenExpression;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.k2js.declarations.Declarations;
 
 /**
  * @author Talanov Pavel
@@ -45,11 +46,6 @@ public final class Translation {
         return OperationTranslator.newInstance(context);
     }
 
-    @NotNull
-    static public NamespaceDeclarationTranslator declarationTranslator(@NotNull TranslationContext context) {
-        return NamespaceDeclarationTranslator.newInstance(context);
-    }
-
     @NotNull
     static public PatternTranslator patternTranslator(@NotNull TranslationContext context) {
         return PatternTranslator.newInstance(context);
@@ -79,4 +75,11 @@ public final class Translation {
     static public JsNode translateWhenExpression(@NotNull JetWhenExpression expression, @NotNull TranslationContext context) {
         return WhenTranslator.translateWhenExpression(expression, context);
     }
+
+    public static void generateAst(@NotNull JsProgram result, @NotNull BindingContext bindingContext,
+                                   @NotNull Declarations declarations, @NotNull JetNamespace namespace) {
+        JsBlock block = result.getFragmentBlock(0);
+        TranslationContext context = TranslationContext.rootContext(result, bindingContext, declarations);
+        block.addStatement(Translation.namespaceTranslator(context).translateNamespace(namespace));
+    }
 }

translator/test/org/jetbrains/k2js/test/AbstractExpressionTest.java

@@ -1,20 +1,12 @@
 package org.jetbrains.k2js.test;
 
-import java.util.Arrays;
-import java.util.List;
-
 /**
  * @author Talanov Pavel
  */
-public abstract class AbstractExpressionTest extends TranslationTest {
+public abstract class AbstractExpressionTest extends IncludeLibraryTest {
 
     private final String SUITE = "expression/";
 
-    @Override
-    protected List<String> generateFilenameList(String inputFile) {
-        return Arrays.asList(inputFile);
-    }
-
     @Override
     protected String suiteDirectoryName() {
         return SUITE;

translator/test/org/jetbrains/k2js/test/KotlinLibTest.java

@@ -7,21 +7,15 @@ import org.mozilla.javascript.Scriptable;
 
 import java.util.Arrays;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 /**
  * @author Talanov Pavel
  */
-public class KotlinLibTest extends TranslationTest {
+public class KotlinLibTest extends IncludeLibraryTest {
 
     final private static String MAIN = "kotlinLib/";
 
-    @Override
-    protected List<String> generateFilenameList(String inputFile) {
-        return Arrays.asList(kotlinLibraryPath());
-    }
-
     @Override
     protected String mainDirectory() {
         return MAIN;
@@ -74,6 +68,33 @@ public class KotlinLibTest extends TranslationTest {
                 new RhinoPropertyTypesChecker("foo", propertyToType));
     }
 
+    @Test
+    public void createdNamespaceIsJSObject() throws Exception {
+        final Map<String, Class<? extends Scriptable>> propertyToType
+                = new HashMap<String, Class<? extends Scriptable>>();
+        runRhinoTest(Arrays.asList(kotlinLibraryPath(), cases("namespace.js")),
+                new RhinoPropertyTypesChecker("foo", propertyToType));
+    }
+
+    @Test
+    public void namespaceHasDeclaredFunction() throws Exception {
+        runRhinoTest(Arrays.asList(kotlinLibraryPath(), cases("namespace.js")),
+                new RhinoFunctionResultChecker("test", true));
+    }
+
+
+    @Test
+    public void namespaceHasDeclaredClasses() throws Exception {
+        runRhinoTest(Arrays.asList(kotlinLibraryPath(), cases("namespaceWithClasses.js")),
+                new RhinoFunctionResultChecker("test", true));
+    }
+
+    @Test
+    public void namespacePropertyAccess() throws Exception {
+        runRhinoTest(Arrays.asList(kotlinLibraryPath(), cases("namespace2.js")),
+                new RhinoFunctionResultChecker("test", true));
+    }
+
     @Test
     public void isSameType() throws Exception {
         runRhinoTest(Arrays.asList(kotlinLibraryPath(), cases("isSameType.js")),

translator/test/org/jetbrains/k2js/test/PropertyAccessorTest.java

@@ -49,6 +49,16 @@ public final class PropertyAccessorTest extends IncludeLibraryTest {
         testFooBoxIsTrue("safeCallReturnsNullIfFails.kt");
     }
 
+    @Test
+    public void namespacePropertyInitializer() throws Exception {
+        testFooBoxIsTrue("namespacePropertyInitializer.kt");
+    }
+
+    @Test
+    public void namespacePropertySet() throws Exception {
+        testFooBoxIsTrue("namespacePropertySet.kt");
+    }
+
     //TODO test
 //    @Test
 //    public void namespaceCustomAccessors() throws Exception {

translator/test/org/jetbrains/k2js/test/RhinoFunctionResultChecker.java

@@ -2,8 +2,6 @@ package org.jetbrains.k2js.test;
 
 import org.jetbrains.annotations.Nullable;
 import org.mozilla.javascript.Context;
-import org.mozilla.javascript.Function;
-import org.mozilla.javascript.NativeObject;
 import org.mozilla.javascript.Scriptable;
 
 import static org.junit.Assert.assertTrue;
@@ -29,43 +27,22 @@ public final class RhinoFunctionResultChecker implements RhinoResultChecker {
 
     @Override
     public void runChecks(Context context, Scriptable scope) throws Exception {
-        Object result = extractAndCallFunctionObject(namespaceName, functionName, context, scope);
+        Object result = evaluateFunction(context, scope);
         assertTrue("Result is not what expected! Expected: " + expectedResult + " Evaluated : " + result,
                 result.equals(expectedResult));
         String report = namespaceName + "." + functionName + "() = " + Context.toString(result);
         System.out.println(report);
     }
 
-    private Object extractAndCallFunctionObject(String namespaceName, String functionName,
+    private Object evaluateFunction(Context cx, Scriptable scope) {
-                                                Context cx, Scriptable scope) {
+        return cx.evaluateString(scope, functionCallString(), "function call", 0, null);
-        Object functionObject;
+    }
+
+    private String functionCallString() {
+        String result = functionName + "()";
         if (namespaceName != null) {
-            functionObject = extractFunctionFromObject(namespaceName, functionName, scope);
+            result = namespaceName + "." + result;
-        } else {
-            functionObject = extractFunctionFromGlobalScope(functionName, scope);
         }
-        return callFunctionAndCheckResults(cx, scope, (Function) functionObject);
+        return result;
-    }
-
-    private Object callFunctionAndCheckResults(Context cx, Scriptable scope, Function functionObject) {
-        Object functionArgs[] = {};
-        return functionObject.call(cx, scope, scope, functionArgs);
-    }
-
-    private Object extractFunctionFromGlobalScope(String functionName, Scriptable scope) {
-        Object functionObject;
-        functionObject = scope.get(functionName, scope);
-        assertTrue("Function " + functionName + " is not defined in global scope",
-                functionObject instanceof Function);
-        return functionObject;
-    }
-
-    private Object extractFunctionFromObject(String namespaceName, String functionName, Scriptable scope) {
-        Object functionObject;
-        NativeObject namespaceObject = RhinoUtils.extractObject(namespaceName, scope);
-        functionObject = namespaceObject.get(functionName, namespaceObject);
-        assertTrue("Function " + functionName + " is not defined in namespace " + namespaceName,
-                functionObject instanceof Function);
-        return functionObject;
     }
 }

translator/testFiles/expression/function/cases/loopClosure.kt

@@ -5,7 +5,7 @@ var b = 0
 fun loop(var times : Int) {
    while(times > 0) {
         val u : fun(value : Int) : Unit = {
-            b++
+            b = b + 1
         }
         u(times--)
    }

translator/testFiles/kotlinLib/cases/namespace.js

@@ -0,0 +1,10 @@
+foo = Namespace.create({initialize:function(){
+}
+, box:function(){
+  return !false;
+}
+});
+
+function test() {
+    return foo.box()
+}

translator/testFiles/kotlinLib/cases/namespace2.js

@@ -0,0 +1,35 @@
+{
+  classes = function(){
+    return {};
+  }
+  ();
+  foo = Namespace.create(classes, {initialize:function(){
+    this.$b = 0
+  }
+  , set_b:function(tmp$0){
+    this.$b = tmp$0;
+  }
+  , get_b:function(){
+    return this.$b;
+  }
+  , loop:function(times){
+    while (times > 0) {
+      var u = function(){
+        return this.set_b(this.get_b() + 1);
+      }
+      ;
+      u(times--);
+    }
+  }
+  , box:function(){
+    this.loop(5);
+    return this.get_b() === 5;
+  }
+  });
+}
+
+
+
+function test() {
+     return foo.box()
+}

translator/testFiles/kotlinLib/cases/namespaceWithClasses.js

@@ -0,0 +1,45 @@
+{
+  classes = function(){
+    var A = Class.create({initialize:function(){
+      this.$order = '';
+      {
+        this.set_order(this.get_order() + 'A');
+      }
+    }
+    , set_order:function(tmp$0){
+      this.$order = tmp$0;
+    }
+    , get_order:function(){
+      return this.$order;
+    }
+    });
+    var B = Class.create(A, {initialize:function(){
+      this.super_init();
+      {
+        this.set_order(this.get_order() + 'B');
+      }
+    }
+    });
+    var C = Class.create(B, {initialize:function(){
+      this.super_init();
+      {
+        this.set_order(this.get_order() + 'C');
+      }
+    }
+    });
+    return {A:A, B:B, C:C};
+  }
+  ();
+  foo = Namespace.create(classes, {initialize:function(){
+  }
+  , box:function(){
+    return (new foo.C).get_order() === 'ABC' && (new foo.B).get_order() === 'AB' && (new foo.A).get_order() === 'A';
+  }
+  });
+}
+
+
+
+function test() {
+    return foo.box()
+}

translator/testFiles/kotlin_lib.js

@@ -6,9 +6,9 @@ function $A(iterable) {
   return results;
 }
 
-var isType = function(object, class) {
+var isType = function(object, klass) {
     current = object.get_class();
-    while (current !== class) {
+    while (current !== klass) {
         if (current === null) {
             return false;
         }
@@ -101,7 +101,6 @@ var Class = (function() {
 
 var Trait = (function() {
 
-
   function add(object, source) {
     properties = Object.keys(source);
     for (var i = 0, length = properties.length; i < length; i++) {
@@ -132,9 +131,8 @@ var Trait = (function() {
 var Namespace = (function() {
 
   function create() {
-    return Class.create.apply(this, arguments);
+    return Trait.create.apply(Trait, arguments);
   }
-
   return {
     create: create
   };

translator/testFiles/propertyAccess/cases/namespacePropertyInitializer.kt

@@ -0,0 +1,5 @@
+namespace foo
+
+val b = 3
+
+fun box() = (b == 3)

translator/testFiles/propertyAccess/cases/namespacePropertySet.kt

@@ -0,0 +1,8 @@
+namespace foo
+
+var b = 3
+
+fun box() : Boolean {
+    b = 2
+    return (b == 2)
+}