JS backend: added wraping to object the local vars which captured in closure.

Moved local functions and function literals to class/namespace definition.

(cherry picked from commit 36c954b)

Author: develar

js/js.translator/src/org/jetbrains/k2js/translate/context/AliasingContext.java

@@ -18,46 +18,18 @@
 
 import com.google.common.collect.Maps;
 import com.google.dart.compiler.backend.js.ast.JsExpression;
-import com.google.dart.compiler.backend.js.ast.JsLiteral;
 import com.google.dart.compiler.backend.js.ast.JsName;
-import com.google.dart.compiler.backend.js.ast.JsNameRef;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
-import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.JetExpression;
-import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.*;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ThisReceiver;
 
-import java.util.Map;
-
-import static org.jetbrains.k2js.translate.utils.JsDescriptorUtils.getDeclarationDescriptorForReceiver;
-import static org.jetbrains.k2js.translate.utils.JsDescriptorUtils.getExpectedReceiverDescriptor;
+import java.util.*;
 
 public class AliasingContext {
-    private static final ThisAliasProvider EMPTY_THIS_ALIAS_PROVIDER = new ThisAliasProvider() {
-        @Nullable
+    private static final AliasingContext ROOT = new AliasingContext(null) {
         @Override
-        public JsNameRef get(@NotNull DeclarationDescriptor descriptor) {
-            return null;
-        }
-
-        @Nullable
-        @Override
-        public JsExpression get(@NotNull ResolvedCall<?> call) {
-            ReceiverValue callThisObject = call.getThisObject();
-            return callThisObject.exists() && (callThisObject instanceof ClassReceiver || callThisObject instanceof ExtensionReceiver)
-                   ? JsLiteral.THIS
-                   : null;
-        }
-    };
-
-    private static final AliasingContext ROOT = new AliasingContext(null, EMPTY_THIS_ALIAS_PROVIDER) {
-        @Override
-        public JsName getAliasForDescriptor(@NotNull DeclarationDescriptor descriptor) {
+        public JsExpression getAliasForDescriptor(@NotNull DeclarationDescriptor descriptor) {
             return null;
         }
 
@@ -68,114 +40,76 @@ public JsName getAliasForExpression(@NotNull JetExpression element) {
     };
 
     public static AliasingContext getCleanContext() {
-        return new AliasingContext(ROOT, ROOT.thisAliasProvider);
+        return new AliasingContext(ROOT);
     }
 
-    @NotNull
-    private final Map<DeclarationDescriptor, JsName> aliasesForDescriptors = Maps.newHashMap();
+    @Nullable
+    private Map<DeclarationDescriptor, JsExpression> aliasesForDescriptors;
 
-    @NotNull
-    final ThisAliasProvider thisAliasProvider;
     @NotNull
     private final Map<JetExpression, JsName> aliasesForExpressions = Maps.newHashMap();
 
     @Nullable
     private final AliasingContext parent;
 
-    private AliasingContext(@Nullable AliasingContext parent, @NotNull ThisAliasProvider thisAliasProvider) {
-        this.parent = parent;
-        this.thisAliasProvider = thisAliasProvider;
-    }
-
-    public interface ThisAliasProvider {
-        @Nullable
-        JsNameRef get(@NotNull DeclarationDescriptor descriptor);
-        @Nullable
-        JsExpression get(@NotNull ResolvedCall<?> call);
-    }
-
-    public abstract static class AbstractThisAliasProvider implements ThisAliasProvider {
-        @NotNull
-        protected static DeclarationDescriptor normalize(@NotNull DeclarationDescriptor descriptor) {
-            if (descriptor instanceof ClassOrNamespaceDescriptor) {
-                return descriptor;
-            }
-            else if (descriptor instanceof CallableDescriptor) {
-                DeclarationDescriptor receiverDescriptor = getExpectedReceiverDescriptor((CallableDescriptor) descriptor);
-                assert receiverDescriptor != null;
-                return receiverDescriptor;
-            }
-
-            return descriptor;
-        }
-
-        @Nullable
-        @Override
-        public JsExpression get(@NotNull ResolvedCall<?> call) {
-            ReceiverValue thisObject = call.getThisObject();
-            if (!thisObject.exists()) {
-                return null;
-            }
-
-            if (thisObject instanceof ExtensionReceiver || thisObject instanceof ClassReceiver) {
-                JsNameRef ref = get(((ThisReceiver) thisObject).getDeclarationDescriptor());
-                if (ref != null) {
-                    return ref;
-                }
-            }
-
-            JsNameRef ref = get(getDeclarationDescriptorForReceiver(thisObject));
-            return ref == null ? JsLiteral.THIS : ref;
-        }
+    private AliasingContext(@Nullable AliasingContext parent) {
+        this(parent, null);
     }
 
-    @NotNull
-    public AliasingContext inner(@NotNull ThisAliasProvider thisAliasProvider) {
-        return new AliasingContext(this, thisAliasProvider);
+    private AliasingContext(@Nullable AliasingContext parent, @Nullable Map<DeclarationDescriptor, JsExpression> aliasesForDescriptors) {
+        this.parent = parent;
+        this.aliasesForDescriptors = aliasesForDescriptors;
     }
 
     @NotNull
-    public AliasingContext inner(@NotNull final DeclarationDescriptor correspondingDescriptor, @NotNull final JsName alias) {
-        return inner(new AbstractThisAliasProvider() {
-            @Nullable
-            @Override
-            public JsNameRef get(@NotNull DeclarationDescriptor descriptor) {
-                return correspondingDescriptor == normalize(descriptor) ? alias.makeRef() : null;
-            }
-        });
+    public AliasingContext inner(@NotNull DeclarationDescriptor descriptor, @NotNull JsExpression alias) {
+        return new AliasingContext(this, Collections.singletonMap(descriptor, alias));
     }
 
     @NotNull
     public AliasingContext withAliasesForExpressions(@NotNull Map<JetExpression, JsName> aliasesForExpressions) {
-        AliasingContext newContext = new AliasingContext(this, thisAliasProvider);
+        AliasingContext newContext = new AliasingContext(this);
         newContext.aliasesForExpressions.putAll(aliasesForExpressions);
         return newContext;
     }
 
     @NotNull
-    public AliasingContext withDescriptorsAliased(@NotNull Map<DeclarationDescriptor, JsName> aliases) {
-        AliasingContext newContext = new AliasingContext(this, thisAliasProvider);
-        newContext.aliasesForDescriptors.putAll(aliases);
-        return newContext;
+    public AliasingContext withDescriptorsAliased(@NotNull Map<DeclarationDescriptor, JsExpression> aliases) {
+        return new AliasingContext(this, aliases);
     }
 
     @Nullable
-    public JsName getAliasForDescriptor(@NotNull DeclarationDescriptor descriptor) {
-        JsName alias = aliasesForDescriptors.get(descriptor.getOriginal());
+    public JsExpression getAliasForDescriptor(@NotNull DeclarationDescriptor descriptor) {
+        if (aliasesForDescriptors == null) {
+            return null;
+        }
+
+        JsExpression alias = aliasesForDescriptors.get(descriptor.getOriginal());
         if (alias != null) {
             return alias;
         }
-        assert parent != null;
+
         return parent.getAliasForDescriptor(descriptor);
     }
 
     @Nullable
     public JsName getAliasForExpression(@NotNull JetExpression element) {
         JsName alias = aliasesForExpressions.get(element);
-        if (alias != null) {
-            return alias;
+        return alias != null ? alias : parent.getAliasForExpression(element);
+    }
+
+    public void registerAlias(@NotNull DeclarationDescriptor descriptor, @NotNull JsExpression alias) {
+        if (aliasesForDescriptors == null) {
+            aliasesForDescriptors = Collections.singletonMap(descriptor, alias);
+        }
+        else {
+            if (aliasesForDescriptors.size() == 1) {
+                Map<DeclarationDescriptor, JsExpression> singletonMap = aliasesForDescriptors;
+                aliasesForDescriptors = new HashMap<DeclarationDescriptor, JsExpression>();
+                aliasesForDescriptors.put(singletonMap.keySet().iterator().next(), singletonMap.values().iterator().next());
+            }
+            JsExpression prev = aliasesForDescriptors.put(descriptor, alias);
+            assert prev == null;
         }
-        assert parent != null;
-        return parent.getAliasForExpression(element);
     }
 }