() {
+ private boolean didIterate = false;
+
+ @Override
+ public boolean hasNext() {
+ return !didIterate;
+ }
+
+ @Override
+ public JsName next() {
+ if (didIterate) {
+ throw new NoSuchElementException();
+ }
+ didIterate = true;
+ return name;
+ }
+
+ @Override
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+
+ };
+ }
+
+ @Override
+ protected JsName doCreateName(String ident, String shortIdent, String originalName) {
+ throw new UnsupportedOperationException("Cannot create a name in a catch scope");
+ }
+
+ @Override
+ public JsName findExistingNameNoRecurse(String ident) {
+ if (name.getIdent().equals(ident)) {
+ return name;
+ } else {
+ return null;
+ }
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsConditional.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsConditional.java
new file mode 100644
index 00000000000..b1171bac2c0
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsConditional.java
@@ -0,0 +1,78 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents a JavaScript conditional expression.
+ */
+public final class JsConditional extends JsExpression {
+
+ private JsExpression elseExpr;
+ private JsExpression testExpr;
+ private JsExpression thenExpr;
+
+ public JsConditional() {
+ }
+
+ public JsConditional(JsExpression testExpr, JsExpression thenExpr, JsExpression elseExpr) {
+ this.testExpr = testExpr;
+ this.thenExpr = thenExpr;
+ this.elseExpr = elseExpr;
+ }
+
+ public JsExpression getElseExpression() {
+ return elseExpr;
+ }
+
+ public JsExpression getTestExpression() {
+ return testExpr;
+ }
+
+ public JsExpression getThenExpression() {
+ return thenExpr;
+ }
+
+ @Override
+ public boolean hasSideEffects() {
+ return testExpr.hasSideEffects() || thenExpr.hasSideEffects() || elseExpr.hasSideEffects();
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ return thenExpr.isDefinitelyNotNull() && elseExpr.isDefinitelyNotNull();
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return thenExpr.isDefinitelyNull() && elseExpr.isDefinitelyNull();
+ }
+
+ public void setElseExpression(JsExpression elseExpr) {
+ this.elseExpr = elseExpr;
+ }
+
+ public void setTestExpression(JsExpression testExpr) {
+ this.testExpr = testExpr;
+ }
+
+ public void setThenExpression(JsExpression thenExpr) {
+ this.thenExpr = thenExpr;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ testExpr = v.accept(testExpr);
+ thenExpr = v.accept(thenExpr);
+ elseExpr = v.accept(elseExpr);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.CONDITIONAL;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsContext.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsContext.java
new file mode 100644
index 00000000000..ddb170052d3
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsContext.java
@@ -0,0 +1,27 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * The context in which a JsNode visitation occurs. This represents the set of
+ * possible operations a JsVisitor subclass can perform on the currently visited
+ * node.
+ */
+public interface JsContext {
+
+ boolean canInsert();
+
+ boolean canRemove();
+
+ void insertAfter(JsVisitable node);
+
+ void insertBefore(JsVisitable node);
+
+ boolean isLvalue();
+
+ void removeMe();
+
+ void replaceMe(JsVisitable node);
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsContinue.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsContinue.java
new file mode 100644
index 00000000000..d761815fe76
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsContinue.java
@@ -0,0 +1,46 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents the JavaScript continue statement.
+ */
+public final class JsContinue extends JsStatement {
+
+ private final JsNameRef label;
+
+ public JsContinue() {
+ this(null);
+ }
+
+ public JsContinue(JsNameRef label) {
+ super();
+ this.label = label;
+ }
+
+ public JsNameRef getLabel() {
+ return label;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ if (label != null) {
+ v.accept(label);
+ }
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public boolean unconditionalControlBreak() {
+ return true;
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.CONTINUE;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsDebugger.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsDebugger.java
new file mode 100644
index 00000000000..34cfae43f48
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsDebugger.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents a JavaScript debugger statement.
+ */
+public class JsDebugger extends JsStatement {
+
+ public JsDebugger() {
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ v.visit(this, ctx);
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.DEBUGGER;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsDefault.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsDefault.java
new file mode 100644
index 00000000000..a76987a8e5d
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsDefault.java
@@ -0,0 +1,28 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents the default option in a JavaScript swtich statement.
+ */
+public final class JsDefault extends JsSwitchMember {
+
+ public JsDefault() {
+ super();
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ v.acceptWithInsertRemove(stmts);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.DEFAULT;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsDoWhile.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsDoWhile.java
new file mode 100644
index 00000000000..1dd4a47e8d4
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsDoWhile.java
@@ -0,0 +1,54 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents a JavaScript do..while statement.
+ */
+public class JsDoWhile extends JsStatement {
+
+ private JsStatement body;
+ private JsExpression condition;
+
+ public JsDoWhile() {
+ super();
+ }
+
+ public JsDoWhile(JsExpression condition, JsStatement body) {
+ super();
+ this.condition = condition;
+ this.body = body;
+ }
+
+ public JsStatement getBody() {
+ return body;
+ }
+
+ public JsExpression getCondition() {
+ return condition;
+ }
+
+ public void setBody(JsStatement body) {
+ this.body = body;
+ }
+
+ public void setCondition(JsExpression condition) {
+ this.condition = condition;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ body = v.accept(body);
+ condition = v.accept(condition);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.DO;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsEmpty.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsEmpty.java
new file mode 100644
index 00000000000..c2ac99e3ac0
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsEmpty.java
@@ -0,0 +1,26 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents an empty statement in JavaScript.
+ */
+public class JsEmpty extends JsStatement {
+
+ // Interned by JsProgram
+ JsEmpty() {
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ v.visit(this, ctx);
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.EMPTY;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsExprStmt.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsExprStmt.java
new file mode 100644
index 00000000000..5b9fc1218c3
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsExprStmt.java
@@ -0,0 +1,36 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents a JavaScript expression statement.
+ */
+public final class JsExprStmt extends JsStatement {
+
+ private JsExpression expr;
+
+ public JsExprStmt(JsExpression expr) {
+ super();
+ this.expr = expr;
+ this.setSourceInfo(expr);
+ }
+
+ public JsExpression getExpression() {
+ return expr;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ expr = v.accept(expr);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.EXPR_STMT;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsExpression.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsExpression.java
new file mode 100644
index 00000000000..43545ec98dc
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsExpression.java
@@ -0,0 +1,52 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import com.google.dart.compiler.common.SourceInfo;
+
+/**
+ * An abstract base class for all JavaScript expressions.
+ */
+public abstract class JsExpression extends JsNode {
+
+ protected JsExpression() {
+ }
+
+ /**
+ * Determines whether the expression can cause side effects.
+ */
+ public abstract boolean hasSideEffects();
+
+ /**
+ * True if the target expression is definitely not null.
+ */
+ public abstract boolean isDefinitelyNotNull();
+
+ /**
+ * True if the target expression is definitely null.
+ */
+ public abstract boolean isDefinitelyNull();
+
+ /**
+ * Determines whether or not this expression is a leaf, such as a
+ * {@link JsNameRef}, {@link JsBooleanLiteral}, and so on. Leaf expressions
+ * never need to be parenthesized.
+ */
+ public boolean isLeaf() {
+ // Conservatively say that it isn't a leaf.
+ // Individual subclasses can speak for themselves if they are a leaf.
+ return false;
+ }
+
+ public JsExprStmt makeStmt() {
+ return new JsExprStmt(this);
+ }
+
+ @Override
+ public JsExpression setSourceRef(SourceInfo info) {
+ super.setSourceRef(info);
+ return this;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsFor.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsFor.java
new file mode 100644
index 00000000000..b980d4be1a2
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsFor.java
@@ -0,0 +1,105 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import com.google.dart.compiler.common.SourceInfo;
+
+/**
+ * A for statement. If specified at all, the initializer part is
+ * either a declaration of one or more variables, in which case
+ * {@link #getInitVars()} is used, or an expression, in which case
+ * {@link #getInitExpr()} is used. In the latter case, the comma operator is
+ * often used to create a compound expression.
+ *
+ *
+ * Note that any of the parts of the for loop header can be
+ * null, although the body will never be null.
+ */
+public class JsFor extends JsStatement {
+
+ private JsStatement body;
+ private JsExpression condition;
+ private JsExpression incrExpr;
+ private JsExpression initExpr;
+ private JsVars initVars;
+
+ public JsFor() {
+ super();
+ }
+
+ public JsStatement getBody() {
+ return body;
+ }
+
+ public JsExpression getCondition() {
+ return condition;
+ }
+
+ public JsExpression getIncrExpr() {
+ return incrExpr;
+ }
+
+ public JsExpression getInitExpr() {
+ return initExpr;
+ }
+
+ public JsVars getInitVars() {
+ return initVars;
+ }
+
+ public void setBody(JsStatement body) {
+ this.body = body;
+ }
+
+ public void setCondition(JsExpression condition) {
+ this.condition = condition;
+ }
+
+ public void setIncrExpr(JsExpression incrExpr) {
+ this.incrExpr = incrExpr;
+ }
+
+ public void setInitExpr(JsExpression initExpr) {
+ this.initExpr = initExpr;
+ }
+
+ public void setInitVars(JsVars initVars) {
+ this.initVars = initVars;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ assert (!(initExpr != null && initVars != null));
+
+ if (initExpr != null) {
+ initExpr = v.accept(initExpr);
+ } else if (initVars != null) {
+ initVars = v.accept(initVars);
+ }
+
+ if (condition != null) {
+ condition = v.accept(condition);
+ }
+
+ if (incrExpr != null) {
+ incrExpr = v.accept(incrExpr);
+ }
+ body = v.accept(body);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public JsFor setSourceRef(SourceInfo info) {
+ super.setSourceRef(info);
+ return this;
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.FOR;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsForIn.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsForIn.java
new file mode 100644
index 00000000000..646e349885c
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsForIn.java
@@ -0,0 +1,71 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents a JavaScript for..in statement.
+ */
+public class JsForIn extends JsStatement {
+
+ private JsStatement body;
+ private JsExpression iterExpr;
+ private JsExpression objExpr;
+
+ // Optional: the name of a new iterator variable to introduce
+ private final JsName iterVarName;
+
+ public JsForIn() {
+ this(null);
+ }
+
+ public JsForIn(JsName iterVarName) {
+ this.iterVarName = iterVarName;
+ }
+
+ public JsStatement getBody() {
+ return body;
+ }
+
+ public JsExpression getIterExpr() {
+ return iterExpr;
+ }
+
+ public JsName getIterVarName() {
+ return iterVarName;
+ }
+
+ public JsExpression getObjExpr() {
+ return objExpr;
+ }
+
+ public void setBody(JsStatement body) {
+ this.body = body;
+ }
+
+ public void setIterExpr(JsExpression iterExpr) {
+ this.iterExpr = iterExpr;
+ }
+
+ public void setObjExpr(JsExpression objExpr) {
+ this.objExpr = objExpr;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ if (iterExpr != null) {
+ iterExpr = v.acceptLvalue(iterExpr);
+ }
+ objExpr = v.accept(objExpr);
+ body = v.accept(body);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.FOR_IN;
+ }
+}
\ No newline at end of file
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsFunction.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsFunction.java
new file mode 100644
index 00000000000..f2c7d258791
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsFunction.java
@@ -0,0 +1,238 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import com.google.dart.compiler.common.SourceInfo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents a JavaScript function expression.
+ */
+public final class JsFunction extends JsLiteral implements HasName {
+
+ private static void trace(String title, String code) {
+ System.out.println("---------------------------");
+ System.out.println(title + ":");
+ System.out.println("---------------------------");
+ System.out.println(code);
+ }
+
+ protected JsBlock body;
+ protected final List params = new ArrayList();
+ protected final JsScope scope;
+ private boolean artificiallyRescued;
+ private boolean executeOnce;
+ private boolean fromDart;
+ private JsFunction impliedExecute;
+ private JsName name;
+ private boolean trace = false;
+ private boolean traceFirst = true;
+ private boolean hoisted = false;
+ private boolean constructor = false;
+
+ /**
+ * Creates an anonymous function.
+ */
+ public JsFunction(JsScope parent) {
+ this(parent, null, false);
+ }
+
+ /**
+ * Creates a function that is not derived from Dart source.
+ */
+ public JsFunction(JsScope parent, JsName name) {
+ this(parent, name, false);
+ }
+
+ /**
+ * Creates a named function, possibly derived from Dart source.
+ */
+ public JsFunction(JsScope parent, JsName name, boolean fromDart) {
+ assert (parent != null);
+ this.fromDart = fromDart;
+ setName(name);
+ String scopeName = (name == null) ? "" : name.getIdent();
+ scopeName = "function " + scopeName;
+ this.scope = new JsScope(parent, scopeName);
+ }
+
+ public JsBlock getBody() {
+ return body;
+ }
+
+ /**
+ * If true, this indicates that only the first invocation of the function will
+ * have any effects. Subsequent invocations may be considered to be no-op
+ * calls whose return value is ignored.
+ */
+ public boolean getExecuteOnce() {
+ return executeOnce;
+ }
+
+ public JsFunction getImpliedExecute() {
+ return impliedExecute;
+ }
+
+ @Override
+ public JsName getName() {
+ return name;
+ }
+
+ public void setParameters(List params) {
+ this.params.clear();
+ this.params.addAll(params);
+ }
+
+ public List getParameters() {
+ return params;
+ }
+
+ public JsScope getScope() {
+ return scope;
+ }
+
+ @Override
+ public boolean hasSideEffects() {
+ // If there's a name, the name is assigned to.
+ return name != null;
+ }
+
+ public boolean isArtificiallyRescued() {
+ return artificiallyRescued;
+ }
+
+ @Override
+ public boolean isBooleanFalse() {
+ return false;
+ }
+
+ @Override
+ public boolean isBooleanTrue() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return false;
+ }
+
+ public boolean isFromDart() {
+ return fromDart;
+ }
+
+ public void setArtificiallyRescued(boolean rescued) {
+ this.artificiallyRescued = rescued;
+ }
+
+ public void setBody(JsBlock body) {
+ this.body = body;
+ }
+
+ public void setExecuteOnce(boolean executeOnce) {
+ this.executeOnce = executeOnce;
+ }
+
+ public void setFromDart(boolean fromDart) {
+ this.fromDart = fromDart;
+ }
+
+ public void setImpliedExecute(JsFunction impliedExecute) {
+ this.impliedExecute = impliedExecute;
+ }
+
+ public void setName(JsName name) {
+ this.name = name;
+ if (name != null) {
+ if (isFromDart()) {
+ name.setStaticRef(this);
+ }
+ }
+ }
+
+ public void setTrace() {
+ this.trace = true;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ String before = null;
+ if (trace && v instanceof JsModVisitor) {
+ before = this.toSource();
+ if (traceFirst) {
+ traceFirst = false;
+ trace("SCRIPT INITIAL", before);
+ }
+ }
+ if (v.visit(this, ctx)) {
+ v.acceptWithInsertRemove(params);
+ body = v.accept(body);
+ }
+ v.endVisit(this, ctx);
+ if (trace && v instanceof JsModVisitor) {
+ String after = this.toSource();
+ if (!after.equals(before)) {
+ String title = v.getClass().getSimpleName();
+ trace(title, after);
+ }
+ }
+ }
+
+ public void setHoisted() {
+ hoisted = true;
+ }
+
+ /**
+ * Whether the function has been hoisted
+ */
+ public boolean isHoisted() {
+ return hoisted;
+ }
+
+ /**
+ * Rebase the function to a new scope.
+ *
+ * @param newScopeParent The scope to add the function to.
+ */
+ public void rebaseScope(JsScope newScopeParent) {
+ this.scope.rebase(newScopeParent);
+ }
+
+ @Override
+ public JsFunction setSourceRef(SourceInfo info) {
+ super.setSourceRef(info);
+ return this;
+ }
+
+ public boolean isConstructor() {
+ return this.constructor;
+ }
+
+ public boolean setIsConstructor(boolean constructor) {
+ return this.constructor = constructor;
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.FUNCTION;
+ }
+
+ // Pavel Talanov
+ // dummy parameter to distinguish from other constructors
+ private JsFunction(Void dummy, JsScope functionScope) {
+ this.fromDart = false;
+ this.scope = functionScope;
+ }
+
+ public static JsFunction getAnonymousFunctionWithScope(JsScope scope) {
+ return new JsFunction(null, scope);
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsGlobalBlock.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsGlobalBlock.java
new file mode 100644
index 00000000000..9a14004e14c
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsGlobalBlock.java
@@ -0,0 +1,19 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represnts a JavaScript block in the global scope.
+ */
+public class JsGlobalBlock extends JsBlock {
+
+ public JsGlobalBlock() {
+ }
+
+ @Override
+ public boolean isGlobalBlock() {
+ return true;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsIf.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsIf.java
new file mode 100644
index 00000000000..478538235ab
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsIf.java
@@ -0,0 +1,65 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents a JavaScript if statement.
+ */
+public final class JsIf extends JsStatement {
+
+ private JsExpression ifExpr;
+ private JsStatement thenStmt;
+ private JsStatement elseStmt;
+
+ public JsIf() {
+ }
+
+ public JsIf(JsExpression ifExpr, JsStatement thenStmt, JsStatement elseStmt) {
+ this.ifExpr = ifExpr;
+ this.thenStmt = thenStmt;
+ this.elseStmt = elseStmt;
+ }
+
+ public JsStatement getElseStmt() {
+ return elseStmt;
+ }
+
+ public JsExpression getIfExpr() {
+ return ifExpr;
+ }
+
+ public JsStatement getThenStmt() {
+ return thenStmt;
+ }
+
+ public void setElseStmt(JsStatement elseStmt) {
+ this.elseStmt = elseStmt;
+ }
+
+ public void setIfExpr(JsExpression ifExpr) {
+ this.ifExpr = ifExpr;
+ }
+
+ public void setThenStmt(JsStatement thenStmt) {
+ this.thenStmt = thenStmt;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ ifExpr = v.accept(ifExpr);
+ thenStmt = v.accept(thenStmt);
+ if (elseStmt != null) {
+ elseStmt = v.accept(elseStmt);
+ }
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.IF;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsInvocation.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsInvocation.java
new file mode 100644
index 00000000000..777c33730d0
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsInvocation.java
@@ -0,0 +1,73 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Represents a JavaScript invocation.
+ */
+public final class JsInvocation extends JsExpression implements HasArguments {
+
+ private final List args = new ArrayList();
+ private JsExpression qualifier;
+
+ public JsInvocation() {
+ }
+
+ @Override
+ public List getArguments() {
+ return args;
+ }
+
+ public JsExpression getQualifier() {
+ return qualifier;
+ }
+
+ @Override
+ public boolean hasSideEffects() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ return false;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return false;
+ }
+
+ public void setQualifier(JsExpression qualifier) {
+ this.qualifier = qualifier;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ qualifier = v.accept(qualifier);
+ v.acceptList(args);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.INVOKE;
+ }
+
+ // Pavel Talanov
+ public void setArguments(List arguments) {
+ assert this.args.isEmpty() : "Arguments already set.";
+ this.args.addAll(arguments);
+ }
+
+ public void setArguments(JsExpression... arguments) {
+ setArguments(Arrays.asList(arguments));
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsLabel.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsLabel.java
new file mode 100644
index 00000000000..7d026c3a6de
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsLabel.java
@@ -0,0 +1,45 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents a JavaScript label statement.
+ */
+public class JsLabel extends JsStatement implements HasName {
+
+ private final JsName label;
+
+ private JsStatement stmt;
+
+ public JsLabel(JsName label) {
+ this.label = label;
+ }
+
+ @Override
+ public JsName getName() {
+ return label;
+ }
+
+ public JsStatement getStmt() {
+ return stmt;
+ }
+
+ public void setStmt(JsStatement stmt) {
+ this.stmt = stmt;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ stmt = v.accept(stmt);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.LABEL;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsLiteral.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsLiteral.java
new file mode 100644
index 00000000000..c87ae0c8af1
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsLiteral.java
@@ -0,0 +1,14 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript string literal expression.
+ */
+public abstract class JsLiteral extends JsExpression implements CanBooleanEval {
+
+ protected JsLiteral() {
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsModVisitor.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsModVisitor.java
new file mode 100644
index 00000000000..ef6e75ce994
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsModVisitor.java
@@ -0,0 +1,189 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import com.google.dart.compiler.util.Hack;
+
+import java.util.List;
+
+/**
+ * A visitor for iterating through and modifying an AST.
+ */
+public class JsModVisitor extends JsVisitor {
+
+ private class ListContext implements JsContext {
+
+ private List collection;
+ private int index;
+ private boolean removed;
+ private boolean replaced;
+
+ @Override
+ public boolean canInsert() {
+ return true;
+ }
+
+ @Override
+ public boolean canRemove() {
+ return true;
+ }
+
+ @Override
+ public void insertAfter(JsVisitable node) {
+ checkRemoved();
+ collection.add(index + 1, Hack.cast(node));
+ didChange = true;
+ }
+
+ @Override
+ public void insertBefore(JsVisitable node) {
+ checkRemoved();
+ collection.add(index++, Hack.cast(node));
+ didChange = true;
+ }
+
+ @Override
+ public boolean isLvalue() {
+ return false;
+ }
+
+ @Override
+ public void removeMe() {
+ checkState();
+ collection.remove(index--);
+ didChange = removed = true;
+ }
+
+ @Override
+ public void replaceMe(JsVisitable node) {
+ checkState();
+ checkReplacement(collection.get(index), node);
+ collection.set(index, Hack.cast(node));
+ didChange = replaced = true;
+ }
+
+ protected void traverse(List collection) {
+ this.collection = collection;
+ for (index = 0; index < collection.size(); ++index) {
+ removed = replaced = false;
+ doTraverse(collection.get(index), this);
+ }
+ }
+
+ private void checkRemoved() {
+ if (removed) {
+ throw new RuntimeException("Node was already removed");
+ }
+ }
+
+ private void checkState() {
+ checkRemoved();
+ if (replaced) {
+ throw new RuntimeException("Node was already replaced");
+ }
+ }
+ }
+
+ private class LvalueContext extends NodeContext {
+ @Override
+ public boolean isLvalue() {
+ return true;
+ }
+ }
+
+ private class NodeContext implements JsContext {
+ private T node;
+ private boolean replaced;
+
+ @Override
+ public boolean canInsert() {
+ return false;
+ }
+
+ @Override
+ public boolean canRemove() {
+ return false;
+ }
+
+ @Override
+ public void insertAfter(JsVisitable node) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void insertBefore(JsVisitable node) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean isLvalue() {
+ return false;
+ }
+
+ @Override
+ public void removeMe() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void replaceMe(JsVisitable node) {
+ if (replaced) {
+ throw new RuntimeException("Node was already replaced");
+ }
+ checkReplacement(this.node, node);
+ this.node = Hack.cast(node);
+ didChange = replaced = true;
+ }
+
+ protected T traverse(T node) {
+ this.node = node;
+ replaced = false;
+ doTraverse(node, this);
+ return this.node;
+ }
+ }
+
+ protected static void checkReplacement(T origNode, T newNode) {
+ if (newNode == null) {
+ throw new RuntimeException("Cannot replace with null");
+ }
+ if (newNode == origNode) {
+ throw new RuntimeException("The replacement is the same as the original");
+ }
+ }
+
+ protected boolean didChange = false;
+
+ @Override
+ public boolean didChange() {
+ return didChange;
+ }
+
+ @Override
+ protected T doAccept(T node) {
+ return new NodeContext().traverse(node);
+ }
+
+ @Override
+ protected void doAcceptList(List collection) {
+ NodeContext ctx = new NodeContext();
+ for (int i = 0, c = collection.size(); i < c; ++i) {
+ ctx.traverse(collection.get(i));
+ if (ctx.replaced) {
+ collection.set(i, ctx.node);
+ }
+ }
+ }
+
+ @Override
+ protected JsExpression doAcceptLvalue(JsExpression expr) {
+ return new LvalueContext().traverse(expr);
+ }
+
+ @Override
+ protected void doAcceptWithInsertRemove(List collection) {
+ new ListContext().traverse(collection);
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsName.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsName.java
new file mode 100644
index 00000000000..ccc1322338a
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsName.java
@@ -0,0 +1,102 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import java.io.Serializable;
+
+/**
+ * An abstract base class for named JavaScript objects.
+ */
+public class JsName implements Serializable {
+ private final JsScope enclosing;
+ private final String ident;
+ private boolean isObfuscatable;
+ private String shortIdent;
+ private String originalName;
+
+ /**
+ * A back-reference to the JsNode that the JsName refers to.
+ */
+ private JsNode staticRef;
+
+ /**
+ * @param ident the unmangled ident to use for this name
+ */
+JsName(JsScope enclosing, String ident, String shortIdent, String originalName) {
+ this.enclosing = enclosing;
+ this.ident = ident;
+ this.shortIdent = shortIdent;
+ if (originalName != null) {
+ this.originalName = originalName;
+ }
+ this.isObfuscatable = true;
+ }
+
+ public JsScope getEnclosing() {
+ return enclosing;
+ }
+
+ public String getIdent() {
+ return ident;
+ }
+
+ public String getShortIdent() {
+ return shortIdent;
+ }
+
+ public String getOriginalName() {
+ return originalName;
+ }
+
+ public JsNode getStaticRef() {
+ return staticRef;
+ }
+
+ public boolean isObfuscatable() {
+ return isObfuscatable;
+ }
+
+ public JsNameRef makeRef() {
+ return new JsNameRef(this);
+ }
+
+ public void setObfuscatable(boolean isObfuscatable) {
+ this.isObfuscatable = isObfuscatable;
+ }
+
+ public void setShortIdent(String shortIdent) {
+ this.shortIdent = shortIdent;
+ }
+
+ /**
+ * Should never be called except on immutable stuff.
+ */
+ public void setStaticRef(JsNode node) {
+ this.staticRef = node;
+ }
+
+ @Override
+ public String toString() {
+ return ident;
+ }
+
+ @Override
+ public int hashCode() {
+ return ident.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof JsName)) {
+ return false;
+ }
+ JsName other = (JsName) obj;
+ return ident.equals(other.ident) && enclosing == other.enclosing;
+ }
+
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNameRef.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNameRef.java
new file mode 100644
index 00000000000..dc26c8fa61a
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNameRef.java
@@ -0,0 +1,113 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents a JavaScript expression that references a name.
+ */
+public final class JsNameRef extends JsExpression implements CanBooleanEval, HasName {
+
+ private String ident;
+ private JsName name;
+ private JsExpression qualifier;
+
+ public JsNameRef(JsName name) {
+ this.name = name;
+ }
+
+ public JsNameRef(String ident) {
+ this.ident = ident;
+ }
+
+ public String getIdent() {
+ return (name == null) ? ident : name.getIdent();
+ }
+
+ @Override
+ public JsName getName() {
+ return name;
+ }
+
+ public JsExpression getQualifier() {
+ return qualifier;
+ }
+
+ public String getShortIdent() {
+ return (name == null) ? ident : name.getShortIdent();
+ }
+
+ @Override
+ public boolean hasSideEffects() {
+ if (qualifier == null) {
+ return false;
+ }
+ if (!qualifier.isDefinitelyNotNull()) {
+ // Could trigger NPE.
+ return true;
+ }
+ return qualifier.hasSideEffects();
+ }
+
+ @Override
+ public boolean isBooleanFalse() {
+ return isDefinitelyNull();
+ }
+
+ @Override
+ public boolean isBooleanTrue() {
+ return false;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ // TODO: look for single-assignment of stuff from Java?
+ return false;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ if (name != null) {
+ return (name.getEnclosing().getProgram().getUndefinedLiteral().getName() == name);
+ }
+ return false;
+ }
+
+ @Override
+ public boolean isLeaf() {
+ if (qualifier == null) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public boolean isResolved() {
+ return name != null;
+ }
+
+ public void resolve(JsName name) {
+ this.name = name;
+ this.ident = null;
+ }
+
+ public void setQualifier(JsExpression qualifier) {
+ this.qualifier = qualifier;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ if (qualifier != null) {
+ qualifier = v.accept(qualifier);
+ }
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.NAME_REF;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNew.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNew.java
new file mode 100644
index 00000000000..68fc366684d
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNew.java
@@ -0,0 +1,66 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents the JavaScript new expression.
+ */
+public final class JsNew extends JsExpression implements HasArguments {
+
+ private final List args = new ArrayList();
+ private JsExpression ctorExpr;
+
+ public JsNew(JsExpression ctorExpr) {
+ this.ctorExpr = ctorExpr;
+ }
+
+ @Override
+ public List getArguments() {
+ return args;
+ }
+
+ public void setArguments(List arguments) {
+ args.clear();
+ args.addAll(arguments);
+ }
+
+ public JsExpression getConstructorExpression() {
+ return ctorExpr;
+ }
+
+ @Override
+ public boolean hasSideEffects() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ // Sadly, in JS it can be!
+ // TODO: analysis could probably determine most instances cannot be null.
+ return false;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return false;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ ctorExpr = v.accept(ctorExpr);
+ v.acceptList(args);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.NEW;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNode.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNode.java
new file mode 100644
index 00000000000..0d4b7aaa714
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNode.java
@@ -0,0 +1,50 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.google.dart.compiler.backend.js.ast;
+
+import com.google.dart.compiler.backend.js.JsSourceGenerationVisitor;
+import com.google.dart.compiler.backend.js.JsToStringGenerationVisitor;
+import com.google.dart.compiler.common.AbstractNode;
+import com.google.dart.compiler.common.SourceInfo;
+import com.google.dart.compiler.util.DefaultTextOutput;
+
+/**
+ * Base class for all JS AST elements.
+ */
+public abstract class JsNode extends AbstractNode implements JsVisitable {
+
+ protected JsNode() {
+ }
+
+ // Causes source generation to delegate to the one visitor
+ public final String toSource() {
+ DefaultTextOutput out = new DefaultTextOutput(false);
+ JsSourceGenerationVisitor v = new JsSourceGenerationVisitor(out);
+ v.accept(this);
+ return out.toString();
+ }
+
+ // Causes source generation to delegate to the one visitor
+ @Override
+ public final String toString() {
+ DefaultTextOutput out = new DefaultTextOutput(false);
+ JsToStringGenerationVisitor v = new JsToStringGenerationVisitor(out);
+ v.accept(this);
+ return out.toString();
+ }
+
+ @Override
+ public SourceInfo getSourceInfo() {
+ return this;
+ }
+
+ public JsNode setSourceRef(SourceInfo info) {
+ if (info != null) {
+ this.setSourceInfo(info);
+ }
+ return this;
+ }
+
+ public abstract NodeKind getKind();
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNullLiteral.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNullLiteral.java
new file mode 100644
index 00000000000..506b2e3f330
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNullLiteral.java
@@ -0,0 +1,46 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript null literal.
+ */
+public final class JsNullLiteral extends JsValueLiteral {
+
+ // Should only be instantiated in JsProgram
+ JsNullLiteral() {
+ }
+
+ @Override
+ public boolean isBooleanFalse() {
+ return true;
+ }
+
+ @Override
+ public boolean isBooleanTrue() {
+ return false;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ return false;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return true;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ v.visit(this, ctx);
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.NULL;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNumberLiteral.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNumberLiteral.java
new file mode 100644
index 00000000000..726c6b0ed27
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsNumberLiteral.java
@@ -0,0 +1,53 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Represents a JavaScript literal decimal expression.
+ */
+public final class JsNumberLiteral extends JsValueLiteral {
+
+ private final double value;
+
+ // Should be interned by JsProgram
+ JsNumberLiteral(double value) {
+ this.value = value;
+ }
+
+ public double getValue() {
+ return value;
+ }
+
+ @Override
+ public boolean isBooleanFalse() {
+ return value == 0.0;
+ }
+
+ @Override
+ public boolean isBooleanTrue() {
+ return value != 0.0;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return false;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ v.visit(this, ctx);
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.NUMBER;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsObjectLiteral.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsObjectLiteral.java
new file mode 100644
index 00000000000..749ed473c21
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsObjectLiteral.java
@@ -0,0 +1,72 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A JavaScript object literal.
+ */
+public final class JsObjectLiteral extends JsLiteral {
+
+ private final List props;
+
+ public JsObjectLiteral() {
+ props = new ArrayList();
+ }
+
+ public JsObjectLiteral(List props) {
+ assert props != null;
+ this.props = props;
+ }
+
+ public List getPropertyInitializers() {
+ return props;
+ }
+
+ @Override
+ public boolean hasSideEffects() {
+ for (JsPropertyInitializer prop : props) {
+ if (prop.hasSideEffects()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public boolean isBooleanFalse() {
+ return false;
+ }
+
+ @Override
+ public boolean isBooleanTrue() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return false;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ v.acceptWithInsertRemove(props);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.OBJECT;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsOperator.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsOperator.java
new file mode 100644
index 00000000000..e4440cbe9ab
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsOperator.java
@@ -0,0 +1,32 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript operator.
+ */
+public interface JsOperator {
+
+ int INFIX = 0x02;
+ int LEFT = 0x01;
+ int POSTFIX = 0x04;
+ int PREFIX = 0x08;
+
+ int getPrecedence();
+
+ String getSymbol();
+
+ boolean isKeyword();
+
+ boolean isLeftAssociative();
+
+ boolean isPrecedenceLessThan(JsOperator other);
+
+ boolean isValidInfix();
+
+ boolean isValidPostfix();
+
+ boolean isValidPrefix();
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsParameter.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsParameter.java
new file mode 100644
index 00000000000..17581ce4084
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsParameter.java
@@ -0,0 +1,34 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript parameter.
+ */
+public final class JsParameter extends JsNode implements HasName {
+
+ private final JsName name;
+
+ public JsParameter(JsName name) {
+ this.name = name;
+ name.setStaticRef(this);
+ }
+
+ @Override
+ public JsName getName() {
+ return name;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ v.visit(this, ctx);
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.PARAMETER;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsPostfixOperation.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsPostfixOperation.java
new file mode 100644
index 00000000000..a33536f6c0d
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsPostfixOperation.java
@@ -0,0 +1,42 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript postfix operation.
+ */
+public final class JsPostfixOperation extends JsUnaryOperation {
+
+ public JsPostfixOperation(JsUnaryOperator op) {
+ this(op, null);
+ }
+
+ public JsPostfixOperation(JsUnaryOperator op, JsExpression arg) {
+ super(op, arg);
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return false;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ super.traverse(v, ctx);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.POSTFIX_OP;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsPrefixOperation.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsPrefixOperation.java
new file mode 100644
index 00000000000..8ce12c7bacd
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsPrefixOperation.java
@@ -0,0 +1,69 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript prefix operation.
+ */
+public final class JsPrefixOperation extends JsUnaryOperation implements CanBooleanEval {
+
+ public JsPrefixOperation(JsUnaryOperator op) {
+ this(op, null);
+ }
+
+ public JsPrefixOperation(JsUnaryOperator op, JsExpression arg) {
+ super(op, arg);
+ }
+
+ @Override
+ public boolean isBooleanFalse() {
+ if (getOperator() == JsUnaryOperator.VOID) {
+ return true;
+ }
+ if (getOperator() == JsUnaryOperator.NOT && getArg() instanceof CanBooleanEval) {
+ CanBooleanEval eval = (CanBooleanEval) getArg();
+ return eval.isBooleanTrue();
+ }
+ return false;
+ }
+
+ @Override
+ public boolean isBooleanTrue() {
+ if (getOperator() == JsUnaryOperator.NOT && getArg() instanceof CanBooleanEval) {
+ CanBooleanEval eval = (CanBooleanEval) getArg();
+ return eval.isBooleanFalse();
+ }
+ if (getOperator() == JsUnaryOperator.TYPEOF) {
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ if (getOperator() == JsUnaryOperator.TYPEOF) {
+ return true;
+ }
+ return getOperator() != JsUnaryOperator.VOID;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return getOperator() == JsUnaryOperator.VOID;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ super.traverse(v, ctx);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.PREFIX_OP;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsProgram.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsProgram.java
new file mode 100644
index 00000000000..c8e4310ba9b
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsProgram.java
@@ -0,0 +1,174 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A JavaScript program.
+ */
+public final class JsProgram extends JsNode {
+
+ private final JsStatement debuggerStmt;
+ private final JsEmpty emptyStmt;
+ private final JsBooleanLiteral falseLiteral;
+ private JsProgramFragment[] fragments;
+ private final Map indexedFunctions = new HashMap();
+ private final JsNullLiteral nullLiteral;
+ private final Map numberLiteralMap =
+ new HashMap();
+ private final JsScope objectScope;
+ private final JsRootScope rootScope;
+ private final Map stringLiteralMap =
+ new HashMap();
+ private final JsScope topScope;
+ private final JsBooleanLiteral trueLiteral;
+
+ /**
+ * Constructs a JavaScript program object.
+ */
+ public JsProgram(String unitId) {
+ rootScope = new JsRootScope(this);
+ topScope = new JsScope(rootScope, "Global", unitId);
+ objectScope = new JsScope(rootScope, "Object");
+ setFragmentCount(1);
+
+ debuggerStmt = new JsDebugger();
+ emptyStmt = new JsEmpty();
+ falseLiteral = new JsBooleanLiteral(false);
+ nullLiteral = new JsNullLiteral();
+ trueLiteral = new JsBooleanLiteral(true);
+ }
+
+ public JsBooleanLiteral getBooleanLiteral(boolean truth) {
+ if (truth) {
+ return getTrueLiteral();
+ }
+ return getFalseLiteral();
+ }
+
+ /**
+ * Gets the {@link JsStatement} to use whenever parsed source include a
+ * debugger statement.
+ */
+ public JsStatement getDebuggerStmt() {
+ return debuggerStmt;
+ }
+
+ public JsEmpty getEmptyStmt() {
+ return emptyStmt;
+ }
+
+ public JsBooleanLiteral getFalseLiteral() {
+ return falseLiteral;
+ }
+
+ public JsBlock getFragmentBlock(int fragment) {
+ if (fragment < 0 || fragment >= fragments.length) {
+ throw new IllegalArgumentException("Invalid fragment: " + fragment);
+ }
+ return fragments[fragment].getGlobalBlock();
+ }
+
+ public int getFragmentCount() {
+ return this.fragments.length;
+ }
+
+ /**
+ * Gets the one and only global block.
+ */
+ public JsBlock getGlobalBlock() {
+ return getFragmentBlock(0);
+ }
+
+ public JsFunction getIndexedFunction(String name) {
+ return indexedFunctions.get(name);
+ }
+
+ public JsNullLiteral getNullLiteral() {
+ return nullLiteral;
+ }
+
+ public JsNumberLiteral getNumberLiteral(double value) {
+ JsNumberLiteral lit = numberLiteralMap.get(value);
+ if (lit == null) {
+ lit = new JsNumberLiteral(value);
+ numberLiteralMap.put(value, lit);
+ }
+
+ return lit;
+ }
+
+ public JsScope getObjectScope() {
+ return objectScope;
+ }
+
+ /**
+ * Gets the quasi-mythical root scope. This is not the same as the top scope;
+ * all unresolvable identifiers wind up here, because they are considered
+ * external to the program.
+ */
+ public JsRootScope getRootScope() {
+ return rootScope;
+ }
+
+ /**
+ * Gets the top level scope. This is the scope of all the statements in the
+ * main program.
+ */
+ public JsScope getScope() {
+ return topScope;
+ }
+
+ /**
+ * Creates or retrieves a JsStringLiteral from an interned object pool.
+ */
+ public JsStringLiteral getStringLiteral(String value) {
+ JsStringLiteral lit = stringLiteralMap.get(value);
+ if (lit == null) {
+ lit = new JsStringLiteral(value);
+ stringLiteralMap.put(value, lit);
+ }
+ return lit;
+ }
+
+ public JsBooleanLiteral getTrueLiteral() {
+ return trueLiteral;
+ }
+
+ public JsNameRef getUndefinedLiteral() {
+ return new JsNameRef("$Dart$Null");
+ }
+
+ public void setFragmentCount(int fragments) {
+ this.fragments = new JsProgramFragment[fragments];
+ for (int i = 0; i < fragments; i++) {
+ this.fragments[i] = new JsProgramFragment();
+ }
+ }
+
+ public void setIndexedFunctions(Map indexedFunctions) {
+ this.indexedFunctions.clear();
+ this.indexedFunctions.putAll(indexedFunctions);
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ for (JsProgramFragment fragment : fragments) {
+ v.accept(fragment);
+ }
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.PROGRAM;
+ }
+
+
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsProgramFragment.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsProgramFragment.java
new file mode 100644
index 00000000000..3c6859e2150
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsProgramFragment.java
@@ -0,0 +1,34 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * One independently loadable fragment of a {@link JsProgram}.
+ */
+public class JsProgramFragment extends JsNode {
+
+ private final JsGlobalBlock globalBlock;
+
+ public JsProgramFragment() {
+ this.globalBlock = new JsGlobalBlock();
+ }
+
+ public JsBlock getGlobalBlock() {
+ return globalBlock;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ v.accept(globalBlock);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.PROGRAM_FRAGMENT;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsPropertyInitializer.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsPropertyInitializer.java
new file mode 100644
index 00000000000..d68d8d01af4
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsPropertyInitializer.java
@@ -0,0 +1,56 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Used in object literals to specify property values by name.
+ */
+public class JsPropertyInitializer extends JsNode {
+
+ private JsExpression labelExpr;
+ private JsExpression valueExpr;
+
+ public JsPropertyInitializer() {
+ }
+
+ public JsPropertyInitializer(JsExpression labelExpr, JsExpression valueExpr) {
+ this.labelExpr = labelExpr;
+ this.valueExpr = valueExpr;
+ }
+
+ public JsExpression getLabelExpr() {
+ return labelExpr;
+ }
+
+ public JsExpression getValueExpr() {
+ return valueExpr;
+ }
+
+ public boolean hasSideEffects() {
+ return labelExpr.hasSideEffects() || valueExpr.hasSideEffects();
+ }
+
+ public void setLabelExpr(JsExpression labelExpr) {
+ this.labelExpr = labelExpr;
+ }
+
+ public void setValueExpr(JsExpression valueExpr) {
+ this.valueExpr = valueExpr;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ labelExpr = v.accept(labelExpr);
+ valueExpr = v.accept(valueExpr);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.PROPERTY_INIT;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsRegExp.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsRegExp.java
new file mode 100644
index 00000000000..158c7a5e092
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsRegExp.java
@@ -0,0 +1,64 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript regular expression.
+ */
+public final class JsRegExp extends JsValueLiteral {
+
+ private String flags;
+ private String pattern;
+
+ public JsRegExp() {
+ }
+
+ public String getFlags() {
+ return flags;
+ }
+
+ public String getPattern() {
+ return pattern;
+ }
+
+ @Override
+ public boolean isBooleanFalse() {
+ return false;
+ }
+
+ @Override
+ public boolean isBooleanTrue() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return false;
+ }
+
+ public void setFlags(String suffix) {
+ this.flags = suffix;
+ }
+
+ public void setPattern(String re) {
+ this.pattern = re;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ v.visit(this, ctx);
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.REGEXP;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsReturn.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsReturn.java
new file mode 100644
index 00000000000..16d90e4b353
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsReturn.java
@@ -0,0 +1,48 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript return statement.
+ */
+public final class JsReturn extends JsStatement {
+
+ private JsExpression expr;
+
+ public JsReturn() {
+ }
+
+ public JsReturn(JsExpression expr) {
+ this.expr = expr;
+ }
+
+ public JsExpression getExpr() {
+ return expr;
+ }
+
+ public void setExpr(JsExpression expr) {
+ this.expr = expr;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ if (expr != null) {
+ expr = v.accept(expr);
+ }
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public boolean unconditionalControlBreak() {
+ return true;
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.RETURN;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsRootScope.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsRootScope.java
new file mode 100644
index 00000000000..33b71f26222
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsRootScope.java
@@ -0,0 +1,50 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import com.google.dart.compiler.backend.js.JsReservedIdentifiers;
+
+/**
+ * The root scope is the parent of every scope. All identifiers in this scope
+ * are not obfuscatable. This scope is prefilled with reserved global
+ * JavaScript symbols.
+ */
+public final class JsRootScope extends JsScope {
+
+ private final JsProgram program;
+
+ public JsRootScope(JsProgram program) {
+ super("Root");
+ this.program = program;
+ }
+
+ @Override
+ public JsProgram getProgram() {
+ return program;
+ }
+
+ @Override
+ protected JsName doCreateName(String ident, String shortIdent, String originalName) {
+ JsName name = super.doCreateName(ident, shortIdent, originalName);
+ name.setObfuscatable(false);
+ return name;
+ }
+
+ @Override
+ public JsName findExistingNameNoRecurse(String ident) {
+ JsName name = super.findExistingNameNoRecurse(ident);
+ if (name == null) {
+ if (JsReservedIdentifiers.getReservedGlobalSymbols().contains(ident)) {
+ /*
+ * Lazily add JsNames for reserved identifiers. Since a JsName for a reserved global symbol
+ * must report a legitimate enclosing scope, we can't simply have a shared set of symbol
+ * names.
+ */
+ name = doCreateName(ident, ident, ident);
+ }
+ }
+ return name;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsScope.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsScope.java
new file mode 100644
index 00000000000..0a4053960b8
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsScope.java
@@ -0,0 +1,308 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import com.google.dart.compiler.util.Lists;
+import com.google.dart.compiler.util.Maps;
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A scope is a factory for creating and allocating
+ * {@link JsName}s. A JavaScript AST is
+ * built in terms of abstract name objects without worrying about obfuscation,
+ * keyword/identifier blacklisting, and so on.
+ *
+ *
+ *
+ * Scopes are associated with
+ * {@link JsFunction}s, but the two are
+ * not equivalent. Functions have scopes, but a scope does not
+ * necessarily have an associated Function. Examples of this include the
+ * {@link JsRootScope} and synthetic
+ * scopes that might be created by a client.
+ *
+ *
+ *
+ * Scopes can have parents to provide constraints when allocating actual
+ * identifiers for names. Specifically, names in child scopes are chosen such
+ * that they do not conflict with names in their parent scopes. The ultimate
+ * parent is usually the global scope (see
+ * {@link JsProgram#getRootScope()}),
+ * but parentless scopes are useful for managing names that are always accessed
+ * with a qualifier and could therefore never be confused with the global scope
+ * hierarchy.
+ */
+public class JsScope implements Serializable {
+
+ private List children = Collections.emptyList();
+ private final String description;
+ private Map names = Collections.emptyMap();
+ private JsScope parent;
+ protected int tempIndex = 0;
+ private final String scopeId;
+
+ /*
+ * Create a scope with parent.
+ */
+ public JsScope(JsScope parent, String description) {
+ this(parent, description, null);
+ }
+
+ /**
+ * Create a scope with parent.
+ */
+ public JsScope(JsScope parent, String description, String scopeId) {
+ assert (parent != null);
+ this.scopeId = scopeId;
+ this.description = description;
+ this.parent = parent;
+ parent.children = Lists.add(parent.children, this);
+ }
+
+ /**
+ * Rebase the function to a new scope.
+ *
+ * @param newParent The scope to add the function to.
+ */
+ public void rebase(JsScope newParent) {
+ detachFromParent();
+ parent = newParent;
+ parent.children = Lists.add(parent.children, this);
+ }
+
+ /**
+ * Rebase the function's children to a new scope.
+ *
+ * @param newParent
+ */
+ public void rebaseChildScopes(JsScope newParent) {
+ if (newParent == this) {
+ return;
+ }
+ parent.children = Lists.addAll(parent.children, children);
+ for (JsScope child : children) {
+ child.parent = newParent;
+ }
+ children = Collections.emptyList();
+ }
+
+ /**
+ * Subclasses can detach and become parentless.
+ */
+ protected void detachFromParent() {
+ JsScope oldParent = parent;
+
+ oldParent.children = Lists.remove(
+ parent.children, oldParent.children.indexOf(this));
+
+ parent = null;
+ }
+
+ /**
+ * Subclasses can be parentless.
+ */
+ protected JsScope(String description) {
+ this.description = description;
+ this.parent = null;
+ this.scopeId = null;
+ }
+
+ /**
+ * Gets a name object associated with the specified ident in this scope,
+ * creating it if necessary.
+ * If the JsName does not exist yet, a new JsName is created. The ident,
+ * short name, and original name of the newly created JsName are equal to
+ * the given ident.
+ *
+ * @param ident An identifier that is unique within this scope.
+ */
+ public JsName declareName(String ident) {
+ JsName name = findExistingNameNoRecurse(ident);
+ if (name != null) {
+ return name;
+ }
+ return doCreateName(ident, ident, ident);
+ }
+
+ /**
+ * Creates a new variable with an unique ident in this scope.
+ * The generated JsName is guaranteed to have an identifier (but not short
+ * name) that does not clash with any existing variables in the scope.
+ * Future declarations of variables might however clash with the temporary
+ * (unless they use this function).
+ */
+ public JsName declareFreshName(String shortName) {
+ String ident = shortName;
+ int counter = 0;
+ while (findExistingNameNoRecurse(ident) != null) {
+ ident = shortName + "_" + counter++;
+ }
+ return doCreateName(ident, shortName, shortName);
+ }
+
+ String getNextTempName() {
+ // TODO(ngeoffray): Decide on a convention for temporary variables
+ // introduced by the compiler.
+ return "tmp$" + (scopeId != null ? scopeId + "$" : "") + tempIndex++;
+ }
+
+ /**
+ * Creates a temporary variable with an unique name in this scope.
+ * The generated temporary is guaranteed to have an identifier (but not short
+ * name) that does not clash with any existing variables in the scope.
+ * Future declarations of variables might however clash with the temporary.
+ */
+ public JsName declareTemporary() {
+ return declareFreshName(getNextTempName());
+ }
+
+ /**
+ * Gets a name object associated with the specified ident in this scope,
+ * creating it if necessary.
+ * If the JsName does not exist yet, a new JsName is created with the given
+ * ident, short name and original name.
+ *
+ * @param ident An identifier that is unique within this scope.
+ * @param shortIdent A "pretty" name that does not have to be unique.
+ * @throws IllegalArgumentException if ident already exists in this scope but
+ * the requested short name does not match the existing short name.
+ */
+ public JsName declareName(String ident, String shortIdent) {
+ return declareName(ident, shortIdent, ident);
+ }
+
+ /**
+ * Gets a name object associated with the specified ident in this scope,
+ * creating it if necessary.
+ * If the JsName does not exist yet, a new JsName is created. The original
+ * name stored in the JsName is equal to the (unmangled) specified originalName.
+ *
+ * @param ident An identifier that is unique within this scope.
+ * @param shortIdent A "pretty" name that does not have to be unique.
+ * @param originalName The original name in the source.
+ * @throws IllegalArgumentException if ident already exists in this scope but
+ * the requested short name does not match the existing short name,
+ * or the original name does not match the existing original name.
+ */
+ public JsName declareName(String ident, String shortIdent, String originalName) {
+ JsName name = findExistingNameNoRecurse(ident);
+ if (name != null) {
+ if (!name.getShortIdent().equals(shortIdent)
+ || !nullableEquals(name.getOriginalName(), originalName)) {
+ throw new IllegalArgumentException("Requested short name " + shortIdent
+ + " conflicts with preexisting short name " + name.getShortIdent() + " for identifier "
+ + ident);
+ }
+ return name;
+ }
+ return doCreateName(ident, shortIdent, originalName);
+ }
+
+ boolean nullableEquals(String s1, String s2) {
+ return (s1 == null) ? (s2 == null) : s1.equals(s2);
+ }
+
+ /**
+ * Attempts to find the name object for the specified ident, searching in this
+ * scope, and if not found, in the parent scopes.
+ *
+ * @return null if the identifier has no associated name
+ */
+ public final JsName findExistingName(String ident) {
+ JsName name = findExistingNameNoRecurse(ident);
+ if (name == null && parent != null) {
+ return parent.findExistingName(ident);
+ }
+ return name;
+ }
+
+ /**
+ * Attempts to find an unobfuscatable name object for the specified ident,
+ * searching in this scope, and if not found, in the parent scopes.
+ *
+ * @return null if the identifier has no associated name
+ */
+ public final JsName findExistingUnobfuscatableName(String ident) {
+ JsName name = findExistingNameNoRecurse(ident);
+ if (name != null && name.isObfuscatable()) {
+ name = null;
+ }
+ if (name == null && parent != null) {
+ return parent.findExistingUnobfuscatableName(ident);
+ }
+ return name;
+ }
+
+ /**
+ * Returns an iterator for all the names defined by this scope.
+ */
+ public Iterator getAllNames() {
+ return names.values().iterator();
+ }
+
+ /**
+ * Returns a list of this scope's child scopes.
+ */
+ public final List getChildren() {
+ return children;
+ }
+
+ /**
+ * Returns the parent scope of this scope, or null if this is the
+ * root scope.
+ */
+ public final JsScope getParent() {
+ return parent;
+ }
+
+ /**
+ * Returns the associated program.
+ */
+ public JsProgram getProgram() {
+ assert (parent != null) : "Subclasses must override getProgram() if they do not set a parent";
+ return parent.getProgram();
+ }
+
+ @Override
+ public final String toString() {
+ if (parent != null) {
+ return description + "->" + parent;
+ } else {
+ return description;
+ }
+ }
+
+ /**
+ * Creates a new name in this scope.
+ */
+ protected JsName doCreateName(String ident, String shortIdent, String originalName) {
+ JsName name = new JsName(this, ident, shortIdent, originalName);
+ names = Maps.putOrdered(names, ident, name);
+ return name;
+ }
+
+ /**
+ * Attempts to find the name object for the specified ident, searching in this
+ * scope only.
+ *
+ * @return null if the identifier has no associated name
+ */
+ public JsName findExistingNameNoRecurse(String ident) {
+ return names.get(ident);
+ }
+
+ /**
+ *
+ * Checks whether this scope owns this name.
+ */
+ public boolean ownsName(JsName name) {
+ return names.containsValue(name);
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsStatement.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsStatement.java
new file mode 100644
index 00000000000..82d37ca1185
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsStatement.java
@@ -0,0 +1,22 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Abstract base class for JavaScript statement objects.
+ */
+public abstract class JsStatement extends JsNode {
+
+ protected JsStatement() {
+ }
+
+ /**
+ * Returns true if this statement definitely causes an abrupt change in flow
+ * control.
+ */
+ public boolean unconditionalControlBreak() {
+ return false;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsStringLiteral.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsStringLiteral.java
new file mode 100644
index 00000000000..77e60c9b89a
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsStringLiteral.java
@@ -0,0 +1,53 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript string literal expression.
+ */
+public final class JsStringLiteral extends JsValueLiteral {
+
+ private final String value;
+
+ // These only get created by JsProgram so that they can be interned.
+ JsStringLiteral(String value) {
+ this.value = value;
+ }
+
+ public String getValue() {
+ return value;
+ }
+
+ @Override
+ public boolean isBooleanFalse() {
+ return value.length() == 0;
+ }
+
+ @Override
+ public boolean isBooleanTrue() {
+ return value.length() != 0;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return false;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ v.visit(this, ctx);
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.STRING;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsSwitch.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsSwitch.java
new file mode 100644
index 00000000000..5a49624af42
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsSwitch.java
@@ -0,0 +1,47 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A JavaScript switch statement.
+ */
+public class JsSwitch extends JsStatement {
+
+ private final List cases = new ArrayList();
+ private JsExpression expr;
+
+ public JsSwitch() {
+ super();
+ }
+
+ public List getCases() {
+ return cases;
+ }
+
+ public JsExpression getExpr() {
+ return expr;
+ }
+
+ public void setExpr(JsExpression expr) {
+ this.expr = expr;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ expr = v.accept(expr);
+ v.acceptWithInsertRemove(cases);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.SWITCH;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsSwitchMember.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsSwitchMember.java
new file mode 100644
index 00000000000..0a748f60078
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsSwitchMember.java
@@ -0,0 +1,24 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A member/case in a JavaScript switch object.
+ */
+public abstract class JsSwitchMember extends JsNode {
+
+ protected final List stmts = new ArrayList();
+
+ protected JsSwitchMember() {
+ super();
+ }
+
+ public List getStmts() {
+ return stmts;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsThisRef.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsThisRef.java
new file mode 100644
index 00000000000..9adb6459488
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsThisRef.java
@@ -0,0 +1,51 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript this reference.
+ */
+public final class JsThisRef extends JsValueLiteral {
+
+ public JsThisRef() {
+ super();
+ }
+
+ @Override
+ public boolean isBooleanFalse() {
+ return false;
+ }
+
+ @Override
+ public boolean isBooleanTrue() {
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNotNull() {
+ /*
+ * You'd think that you could get a null this via function.call/apply, but
+ * in fact you can't: they just make this be the window object instead. So
+ * it really can't ever be null.
+ */
+ return true;
+ }
+
+ @Override
+ public boolean isDefinitelyNull() {
+ return false;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ v.visit(this, ctx);
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.THIS;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsThrow.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsThrow.java
new file mode 100644
index 00000000000..4616418fb6b
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsThrow.java
@@ -0,0 +1,48 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript throw statement.
+ */
+public class JsThrow extends JsStatement {
+
+ private JsExpression expr;
+
+ public JsThrow() {
+ super();
+ }
+
+ public JsThrow(JsExpression expr) {
+ super();
+ this.expr = expr;
+ }
+
+ public JsExpression getExpr() {
+ return expr;
+ }
+
+ public void setExpr(JsExpression expr) {
+ this.expr = expr;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ expr = v.accept(expr);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public boolean unconditionalControlBreak() {
+ return true;
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.THROW;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsTry.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsTry.java
new file mode 100644
index 00000000000..61357bcd406
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsTry.java
@@ -0,0 +1,59 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A JavaScript try statement.
+ */
+public class JsTry extends JsStatement {
+
+ private final List catches = new ArrayList();
+ private JsBlock finallyBlock;
+ private JsBlock tryBlock;
+
+ public JsTry() {
+ super();
+ }
+
+ public List getCatches() {
+ return catches;
+ }
+
+ public JsBlock getFinallyBlock() {
+ return finallyBlock;
+ }
+
+ public JsBlock getTryBlock() {
+ return tryBlock;
+ }
+
+ public void setFinallyBlock(JsBlock block) {
+ this.finallyBlock = block;
+ }
+
+ public void setTryBlock(JsBlock block) {
+ tryBlock = block;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ tryBlock = v.accept(tryBlock);
+ v.acceptWithInsertRemove(catches);
+ if (finallyBlock != null) {
+ finallyBlock = v.accept(finallyBlock);
+ }
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.TRY;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsUnaryOperation.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsUnaryOperation.java
new file mode 100644
index 00000000000..00f103f35c9
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsUnaryOperation.java
@@ -0,0 +1,53 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript prefix or postfix operation.
+ */
+public abstract class JsUnaryOperation extends JsExpression {
+
+ private JsExpression arg;
+
+ private final JsUnaryOperator op;
+
+ public JsUnaryOperation(JsUnaryOperator op) {
+ this(op, null);
+ }
+
+ public JsUnaryOperation(JsUnaryOperator op, JsExpression arg) {
+ super();
+ this.op = op;
+ this.arg = arg;
+ }
+
+ public JsExpression getArg() {
+ return arg;
+ }
+
+ public JsUnaryOperator getOperator() {
+ return op;
+ }
+
+ @Override
+ public final boolean hasSideEffects() {
+ return op.isModifying() || arg.hasSideEffects();
+ }
+
+ public void setArg(JsExpression arg) {
+ this.arg = arg;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (op.isModifying()) {
+ // The delete operator is practically like an assignment of undefined, so
+ // for practical purposes we're treating it as an lvalue.
+ arg = v.acceptLvalue(arg);
+ } else {
+ arg = v.accept(arg);
+ }
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsUnaryOperator.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsUnaryOperator.java
new file mode 100644
index 00000000000..2b854d8313e
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsUnaryOperator.java
@@ -0,0 +1,78 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript unary operator.
+ */
+public enum JsUnaryOperator implements JsOperator {
+
+ /*
+ * Precedence indices from "JavaScript - The Definitive Guide" 4th Edition
+ * (page 57)
+ */
+ BIT_NOT("~", 14, PREFIX), DEC("--", 14, POSTFIX | PREFIX), DELETE("delete", 14, PREFIX), INC(
+ "++", 14, POSTFIX | PREFIX), NEG("-", 14, PREFIX), POS("+", 14, PREFIX),
+ NOT("!", 14, PREFIX), TYPEOF("typeof", 14, PREFIX), VOID("void", 14, PREFIX);
+
+ private final int mask;
+ private final int precedence;
+ private final String symbol;
+
+ private JsUnaryOperator(String symbol, int precedence, int mask) {
+ this.symbol = symbol;
+ this.precedence = precedence;
+ this.mask = mask;
+ }
+
+ @Override
+ public int getPrecedence() {
+ return precedence;
+ }
+
+ @Override
+ public String getSymbol() {
+ return symbol;
+ }
+
+ @Override
+ public boolean isKeyword() {
+ return this == DELETE || this == TYPEOF || this == VOID;
+ }
+
+ @Override
+ public boolean isLeftAssociative() {
+ return (mask & LEFT) != 0;
+ }
+
+ public boolean isModifying() {
+ return this == DEC || this == INC || this == DELETE;
+ }
+
+ @Override
+ public boolean isPrecedenceLessThan(JsOperator other) {
+ return precedence < other.getPrecedence();
+ }
+
+ @Override
+ public boolean isValidInfix() {
+ return (mask & INFIX) != 0;
+ }
+
+ @Override
+ public boolean isValidPostfix() {
+ return (mask & POSTFIX) != 0;
+ }
+
+ @Override
+ public boolean isValidPrefix() {
+ return (mask & PREFIX) != 0;
+ }
+
+ @Override
+ public String toString() {
+ return symbol;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsValueLiteral.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsValueLiteral.java
new file mode 100644
index 00000000000..f23ab5dbce4
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsValueLiteral.java
@@ -0,0 +1,24 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript string literal expression.
+ */
+public abstract class JsValueLiteral extends JsLiteral {
+
+ protected JsValueLiteral() {
+ }
+
+ @Override
+ public final boolean hasSideEffects() {
+ return false;
+ }
+
+ @Override
+ public final boolean isLeaf() {
+ return true;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsVars.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsVars.java
new file mode 100644
index 00000000000..aaf629259aa
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsVars.java
@@ -0,0 +1,109 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import com.google.dart.compiler.common.SourceInfo;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * A JavaScript var statement.
+ */
+public class JsVars extends JsStatement implements Iterable {
+
+ /**
+ * A var declared using the JavaScript var statement.
+ */
+ public static class JsVar extends JsNode implements HasName {
+
+ private final JsName name;
+ private JsExpression initExpr;
+
+ public JsVar(JsName name) {
+ this.name = name;
+ }
+
+ public JsVar(JsName name, JsExpression initExpr) {
+ this.name = name;
+ this.initExpr = initExpr;
+ }
+
+ public JsExpression getInitExpr() {
+ return initExpr;
+ }
+
+ @Override
+ public JsName getName() {
+ return name;
+ }
+
+ public void setInitExpr(JsExpression initExpr) {
+ this.initExpr = initExpr;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ if (initExpr != null) {
+ initExpr = v.accept(initExpr);
+ }
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public JsVar setSourceRef(SourceInfo info) {
+ super.setSourceRef(info);
+ return this;
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.VAR;
+ }
+ }
+
+ private final List vars = new ArrayList();
+
+ public JsVars() {
+ }
+
+ public void add(JsVar var) {
+ vars.add(var);
+ }
+
+ public int getNumVars() {
+ return vars.size();
+ }
+
+ public void insert(JsVar var) {
+ vars.add(var);
+ }
+
+ public boolean isEmpty() {
+ return vars.isEmpty();
+ }
+
+ // Iterator returns JsVar objects
+ @Override
+ public Iterator iterator() {
+ return vars.iterator();
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ v.acceptWithInsertRemove(vars);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.VARS;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsVisitable.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsVisitable.java
new file mode 100644
index 00000000000..626648af8ae
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsVisitable.java
@@ -0,0 +1,19 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * Abstracts the idea that a class can be traversed.
+ */
+public interface JsVisitable {
+
+ /**
+ * Causes this object to have the visitor visit itself and its children.
+ *
+ * @param visitor the visitor that should traverse this node
+ * @param ctx the context of an existing traversal
+ */
+ void traverse(JsVisitor visitor, JsContext ctx);
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsVisitor.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsVisitor.java
new file mode 100644
index 00000000000..5b9cd983d08
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsVisitor.java
@@ -0,0 +1,430 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+import java.util.List;
+
+/**
+ * Implemented by nodes that will visit child nodes.
+ */
+@SuppressWarnings("unused")
+public class JsVisitor {
+
+ protected static final JsContext LVALUE_CONTEXT = new JsContext() {
+
+ @Override
+ public boolean canInsert() {
+ return false;
+ }
+
+ @Override
+ public boolean canRemove() {
+ return false;
+ }
+
+ @Override
+ public void insertAfter(JsVisitable node) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void insertBefore(JsVisitable node) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean isLvalue() {
+ return true;
+ }
+
+ @Override
+ public void removeMe() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void replaceMe(JsVisitable node) {
+ throw new UnsupportedOperationException();
+ }
+ };
+
+ protected static final JsContext UNMODIFIABLE_CONTEXT = new JsContext() {
+
+ @Override
+ public boolean canInsert() {
+ return false;
+ }
+
+ @Override
+ public boolean canRemove() {
+ return false;
+ }
+
+ @Override
+ public void insertAfter(JsVisitable node) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void insertBefore(JsVisitable node) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean isLvalue() {
+ return false;
+ }
+
+ @Override
+ public void removeMe() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void replaceMe(JsVisitable node) {
+ throw new UnsupportedOperationException();
+ }
+ };
+
+ public final T accept(T node) {
+ return this.doAccept(node);
+ }
+
+ public final void acceptList(List collection) {
+ doAcceptList(collection);
+ }
+
+ public JsExpression acceptLvalue(JsExpression expr) {
+ return doAcceptLvalue(expr);
+ }
+
+ public final void acceptWithInsertRemove(List collection) {
+ doAcceptWithInsertRemove(collection);
+ }
+
+ public boolean didChange() {
+ throw new UnsupportedOperationException();
+ }
+
+ public void endVisit(JsArrayAccess x, JsContext ctx) {
+ }
+
+ public void endVisit(JsArrayLiteral x, JsContext ctx) {
+ }
+
+ public void endVisit(JsBinaryOperation x, JsContext ctx) {
+ }
+
+ public void endVisit(JsBlock x, JsContext ctx) {
+ }
+
+ public void endVisit(JsBooleanLiteral x, JsContext ctx) {
+ }
+
+ public void endVisit(JsBreak x, JsContext ctx) {
+ }
+
+ public void endVisit(JsCase x, JsContext ctx) {
+ }
+
+ public void endVisit(JsCatch x, JsContext ctx) {
+ }
+
+ public void endVisit(JsConditional x, JsContext ctx) {
+ }
+
+ public void endVisit(JsContinue x, JsContext ctx) {
+ }
+
+ public void endVisit(JsDebugger x, JsContext ctx) {
+ }
+
+ public void endVisit(JsDefault x, JsContext ctx) {
+ }
+
+ public void endVisit(JsDoWhile x, JsContext ctx) {
+ }
+
+ public void endVisit(JsEmpty x, JsContext ctx) {
+ }
+
+ public void endVisit(JsExprStmt x, JsContext ctx) {
+ }
+
+ public void endVisit(JsFor x, JsContext ctx) {
+ }
+
+ public void endVisit(JsForIn x, JsContext ctx) {
+ }
+
+ public void endVisit(JsFunction x, JsContext ctx) {
+ }
+
+ public void endVisit(JsIf x, JsContext ctx) {
+ }
+
+ public void endVisit(JsInvocation x, JsContext ctx) {
+ }
+
+ public void endVisit(JsLabel x, JsContext ctx) {
+ }
+
+ public void endVisit(JsNameRef x, JsContext ctx) {
+ }
+
+ public void endVisit(JsNew x, JsContext ctx) {
+ }
+
+ public void endVisit(JsNullLiteral x, JsContext ctx) {
+ }
+
+ public void endVisit(JsNumberLiteral x, JsContext ctx) {
+ }
+
+ public void endVisit(JsObjectLiteral x, JsContext ctx) {
+ }
+
+ public void endVisit(JsParameter x, JsContext ctx) {
+ }
+
+ public void endVisit(JsPostfixOperation x, JsContext ctx) {
+ }
+
+ public void endVisit(JsPrefixOperation x, JsContext ctx) {
+ }
+
+ public void endVisit(JsProgram x, JsContext ctx) {
+ }
+
+ public void endVisit(JsProgramFragment x, JsContext ctx) {
+ }
+
+ public void endVisit(JsPropertyInitializer x, JsContext ctx) {
+ }
+
+ public void endVisit(JsRegExp x, JsContext ctx) {
+ }
+
+ public void endVisit(JsReturn x, JsContext ctx) {
+ }
+
+ public void endVisit(JsStringLiteral x, JsContext ctx) {
+ }
+
+ public void endVisit(JsSwitch x, JsContext ctx) {
+ }
+
+ public void endVisit(JsThisRef x, JsContext ctx) {
+ }
+
+ public void endVisit(JsThrow x, JsContext ctx) {
+ }
+
+ public void endVisit(JsTry x, JsContext ctx) {
+ }
+
+ public void endVisit(JsVars.JsVar x, JsContext ctx) {
+ }
+
+ public void endVisit(JsVars x, JsContext ctx) {
+ }
+
+ public void endVisit(JsWhile x, JsContext ctx) {
+ }
+
+ public boolean visit(JsArrayAccess x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsArrayLiteral x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsBinaryOperation x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsBlock x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsBooleanLiteral x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsBreak x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsCase x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsCatch x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsConditional x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsContinue x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsDebugger x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsDefault x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsDoWhile x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsEmpty x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsExprStmt x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsFor x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsForIn x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsFunction x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsIf x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsInvocation x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsLabel x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsNameRef x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsNew x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsNullLiteral x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsNumberLiteral x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsObjectLiteral x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsParameter x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsPostfixOperation x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsPrefixOperation x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsProgram x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsProgramFragment x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsPropertyInitializer x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsRegExp x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsReturn x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsStringLiteral x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsSwitch x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsThisRef x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsThrow x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsTry x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsVars.JsVar x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsVars x, JsContext ctx) {
+ return true;
+ }
+
+ public boolean visit(JsWhile x, JsContext ctx) {
+ return true;
+ }
+
+ protected T doAccept(T node) {
+ doTraverse(node, UNMODIFIABLE_CONTEXT);
+ return node;
+ }
+
+ protected void doAcceptList(List collection) {
+ for (T node : collection) {
+ doTraverse(node, UNMODIFIABLE_CONTEXT);
+ }
+ }
+
+ protected JsExpression doAcceptLvalue(JsExpression expr) {
+ doTraverse(expr, LVALUE_CONTEXT);
+ return expr;
+ }
+
+ protected void doAcceptWithInsertRemove(List collection) {
+ for (T node : collection) {
+ doTraverse(node, UNMODIFIABLE_CONTEXT);
+ }
+ }
+
+ protected void doTraverse(JsVisitable node, JsContext ctx) {
+ node.traverse(this, ctx);
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsWhile.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsWhile.java
new file mode 100644
index 00000000000..c40203bc1f1
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/JsWhile.java
@@ -0,0 +1,52 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+/**
+ * A JavaScript while statement.
+ */
+public class JsWhile extends JsStatement {
+
+ private JsStatement body;
+ private JsExpression condition;
+
+ public JsWhile() {
+ }
+
+ public JsWhile(JsExpression condition, JsStatement body) {
+ this.condition = condition;
+ this.body = body;
+ }
+
+ public JsStatement getBody() {
+ return body;
+ }
+
+ public JsExpression getCondition() {
+ return condition;
+ }
+
+ public void setBody(JsStatement body) {
+ this.body = body;
+ }
+
+ public void setCondition(JsExpression condition) {
+ this.condition = condition;
+ }
+
+ @Override
+ public void traverse(JsVisitor v, JsContext ctx) {
+ if (v.visit(this, ctx)) {
+ condition = v.accept(condition);
+ body = v.accept(body);
+ }
+ v.endVisit(this, ctx);
+ }
+
+ @Override
+ public NodeKind getKind() {
+ return NodeKind.WHILE;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/backend/js/ast/NodeKind.java b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/NodeKind.java
new file mode 100644
index 00000000000..614e4bb3bd9
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/backend/js/ast/NodeKind.java
@@ -0,0 +1,50 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.backend.js.ast;
+
+public enum NodeKind {
+ ARRAY_ACCESS,
+ ARRAY,
+ BINARY_OP,
+ BLOCK,
+ BOOLEAN,
+ BREAK,
+ CASE,
+ CATCH,
+ CONDITIONAL,
+ CONTINUE,
+ DEBUGGER,
+ DEFAULT,
+ DO,
+ EMPTY,
+ EXPR_STMT,
+ FOR,
+ FOR_IN,
+ FUNCTION,
+ IF,
+ INVOKE,
+ LABEL,
+ NAME_REF,
+ NEW,
+ NULL,
+ NUMBER,
+ OBJECT,
+ PARAMETER,
+ POSTFIX_OP,
+ PREFIX_OP,
+ PROGRAM,
+ PROGRAM_FRAGMENT,
+ PROPERTY_INIT,
+ REGEXP,
+ RETURN,
+ STRING,
+ SWITCH,
+ THIS,
+ THROW,
+ TRY,
+ VARS,
+ VAR,
+ WHILE
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/common/AbstractNode.java b/js/js.ast/src/com/google/dart/compiler/common/AbstractNode.java
new file mode 100644
index 00000000000..5b70197dd13
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/common/AbstractNode.java
@@ -0,0 +1,81 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.common;
+
+import com.google.dart.compiler.Source;
+
+/**
+ * Abstract base class for nodes that carry source information.
+ */
+public class AbstractNode implements SourceInfo, HasSourceInfo {
+
+ // TODO(johnlenz): All this source location data is wasteful.
+ // Move it into a com.google.dart.compiler.backend.common object, that can be shared between the ASTs
+ // or something.
+ protected Source source = null;
+ protected int sourceLine = -1;
+ protected int sourceColumn = -1;
+ protected int sourceStart = -1;
+ protected int sourceLength = -1;
+
+ @Override
+ public Source getSource() {
+ return source;
+ }
+
+ @Override
+ public int getSourceLine() {
+ return sourceLine;
+ }
+
+ @Override
+ public int getSourceColumn() {
+ return sourceColumn;
+ }
+
+ @Override
+ public int getSourceStart() {
+ return sourceStart;
+ }
+
+ @Override
+ public int getSourceLength() {
+ return sourceLength;
+ }
+
+ @Override
+ public SourceInfo getSourceInfo() {
+ return this;
+ }
+
+ @Override
+ public void setSourceInfo(SourceInfo info) {
+ source = info.getSource();
+ sourceStart = info.getSourceStart();
+ sourceLength = info.getSourceLength();
+ sourceLine = info.getSourceLine();
+ sourceColumn = info.getSourceColumn();
+ }
+
+ @Override
+ public final void setSourceLocation(
+ Source source, int line, int column, int startPosition, int length) {
+ assert (startPosition != -1 && length >= 0
+ || startPosition == -1 && length == 0);
+ this.source = source;
+ this.sourceLine = line;
+ this.sourceColumn = column;
+ this.sourceStart = startPosition;
+ this.sourceLength = length;
+ }
+
+ public final void setSourceRange(int startPosition, int length) {
+ assert (startPosition != -1 && length >= 0
+ || startPosition == -1 && length == 0);
+ this.sourceStart = startPosition;
+ this.sourceLength = length;
+ }
+
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/common/HasSourceInfo.java b/js/js.ast/src/com/google/dart/compiler/common/HasSourceInfo.java
new file mode 100644
index 00000000000..bda3da94996
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/common/HasSourceInfo.java
@@ -0,0 +1,55 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.common;
+
+import com.google.dart.compiler.Source;
+
+/**
+ * Abstract view of a class that has source info.
+ */
+public interface HasSourceInfo {
+
+ /**
+ * Return the source info associated with this object.
+ */
+ SourceInfo getSourceInfo();
+
+ /**
+ * Set the source info associated with this object. May only be called once.
+ * @param info
+ */
+ void setSourceInfo(SourceInfo info);
+
+ /**
+ * Sets the source range of the original source file where the source fragment
+ * corresponding to this node was found.
+ *
+ *
+ * Each node in the subtree (other than the contrived nodes) carries source
+ * range(s) information relating back to positions in the given source (the
+ * given source itself is not remembered with the AST). The source range
+ * usually begins at the first character of the first token corresponding to
+ * the node; leading whitespace and comments are not included. The
+ * source range usually extends through the last character of the last token
+ * corresponding to the node; trailing whitespace and comments are not
+ * included. There are a handful of exceptions (including the various body
+ * declarations). Source ranges nest properly: the source range for a child is
+ * always within the source range of its parent, and the source ranges of
+ * sibling nodes never overlap.
+ *
+ * @param source the associated source
+ * @param line the 1-based line index, or -1, if no source
+ * location is available
+ * @param column the 1-based column index, or -1, if no source
+ * location is available
+ * @param startPosition a 0-based character index, or -1, if no
+ * source location is available
+ * @param length a (possibly 0) length, or -1, if no source
+ * location is available
+ * @see SourceInfo#getSourceStart()
+ * @see SourceInfo#getSourceLength()
+ */
+ void setSourceLocation(Source source, int line, int column, int startPosition, int length);
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/common/Name.java b/js/js.ast/src/com/google/dart/compiler/common/Name.java
new file mode 100644
index 00000000000..4697b491d96
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/common/Name.java
@@ -0,0 +1,121 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.common;
+
+import java.io.*;
+import java.nio.charset.Charset;
+
+/**
+ * Instead of Strings, we use GlobalNames to abstract the underlying representation.
+ *
+ *
+ * - GlobalNames are globally unique and use identity for equality.
+ * - GlobalNames are interned, so all references to the same name use the same
+ * bytes.
+ *
+ * TODO(scottb): use byte[] instead of char[] when the parser is rewritten
+ * to parse byte[].
+ */
+public final class Name implements Serializable {
+
+ /**
+ * The encoding this class uses when converting between chars and bytes.
+ */
+ public static final Charset CHARSET = Charset.forName("UTF-8");
+
+ private static final NameFactory factory = new NameFactory();
+
+ private static final long serialVersionUID = 0L;
+
+ /**
+ * Return the Name corresponding to the data. An internal reference to
+ * data is kept for efficiency, do NOT mutate data after calling
+ * this method.
+ */
+ public static Name of(char[] data) {
+ return factory.of(data);
+ }
+
+ /**
+ * Return the Name corresponding to the data. An internal copy of the data is
+ * made.
+ */
+ public static Name of(char[] data, int offset, int length) {
+ return factory.of(data, offset, length);
+ }
+
+ static int computeHashCode(char[] data, int offset, int length) {
+ // Effective Java Item 9.
+ int result = 89;
+ for (int i = offset, end = offset + length; i < end; ++i) {
+ result *= 31;
+ result += data[i];
+ }
+ return result;
+ }
+
+ final char[] data;
+
+ private final transient int hashCode;
+
+ Name(char[] data, int hashCode) {
+ this.data = data;
+ this.hashCode = hashCode;
+ }
+
+ /**
+ * Always compares based on identity.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ return this == obj;
+ }
+
+ /**
+ * Returns the hashCode of the underlying data.
+ */
+ @Override
+ public int hashCode() {
+ return hashCode;
+ }
+
+ /**
+ * Constructs a String to represent the internal data.
+ */
+ @Override
+ public String toString() {
+ return String.valueOf(data);
+ }
+
+ /**
+ * Write my data into a {@link java.io.OutputStream} using the encoding specified in
+ * {@link #CHARSET}.
+ */
+ public void writeBytesTo(OutputStream out) throws IOException {
+ // TODO(scottb): avoid allocating the String.
+ out.write(new String(data).getBytes(CHARSET));
+ }
+
+ /**
+ * Write my character data into a {@link java.io.PrintStream}.
+ */
+ public void writeCharsTo(PrintStream out) {
+ out.print(data);
+ }
+
+ /**
+ * Write my character data into a {@link java.io.Writer}.
+ */
+ public void writeCharsTo(Writer writer) throws IOException {
+ writer.write(data);
+ }
+
+ /**
+ * Replace with the canonical instance.
+ */
+ private Object readResolve() {
+ return Name.of(data);
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/common/NameFactory.java b/js/js.ast/src/com/google/dart/compiler/common/NameFactory.java
new file mode 100644
index 00000000000..d305f290bf9
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/common/NameFactory.java
@@ -0,0 +1,226 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.common;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.MapMaker;
+
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.util.Arrays;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * Manages the life cycle, uniqueness, and object identity invariants of
+ * {@link Name}.
+ */
+final class NameFactory {
+ /*
+ * TODO: does this actually save memory in practice? For each interned Name,
+ * we use:
+ *
+ * 1) The data array (n bytes).
+ *
+ * 2) The Name object (2 fields)
+ *
+ * 3) The RealKey (1 field + 4 fields from Reference).
+ *
+ * 4) ConcurrentMap.Entry (4 fields)
+ *
+ * Of course, a Map is really much heavier than we need, all we really need is
+ * a Set where you can retrieve an object already in the Set. A bare linear
+ * probe hash table of RealKey would let us get rid of the Entry object.
+ */
+
+ /**
+ * The whole point of this class is to cheaply create a light-weight key that
+ * doesn't need to make its own copy of the data. This object is constructed
+ * with equality semantics to {com.google.dart.compiler.backend.common.NameFactory.RealKey}, for doing cheap map lookups.
+ */
+ private static final class FakeKey {
+ private final char[] data;
+ private final int hashCode;
+ private final int length;
+ private final int offset;
+
+ public FakeKey(char[] data, int hashCode) {
+ this(data, 0, data.length, hashCode);
+ }
+
+ public FakeKey(char[] data, int offset, int length, int hashCode) {
+ this.data = data;
+ this.offset = offset;
+ this.length = length;
+ this.hashCode = hashCode;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ /*
+ * NOTE: this ONLY WORKS for comparisons to RealKey. But that's all we
+ * need since we only store real keys in the map.
+ */
+ Name name = ((RealKey) obj).get();
+ if (name == null) {
+ return false;
+ }
+ return equalsName(name);
+ }
+
+ public boolean equalsName(Name name) {
+ if (this.length != name.data.length) {
+ return false;
+ }
+ int itMine = this.offset;
+ int itTheirs = 0;
+ int endMine = this.offset + this.length;
+ while (itMine < endMine) {
+ if (this.data[itMine++] != name.data[itTheirs++]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return hashCode;
+ }
+
+ @Override
+ public String toString() {
+ return "FakeKey(" + String.valueOf(data, offset, length) + ")";
+ }
+ }
+
+ /**
+ * Adapted from {@link com.google.common.collect.Interners#newWeakInterner()}.
+ */
+ private static final class RealKey extends WeakReference {
+ /**
+ * Must store the hashCode locally so we can be removed from
+ * {com.google.dart.compiler.backend.common.NameFactory#map} after our referent is cleared.
+ */
+ private final int hashCode;
+
+ public RealKey(Name name, ReferenceQueue queue) {
+ super(name, queue);
+ hashCode = name.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (obj instanceof FakeKey) {
+ Name referent = get();
+ if (referent == null) {
+ return false;
+ }
+ return ((FakeKey) obj).equalsName(referent);
+ }
+ if (obj instanceof RealKey) {
+ Name referent = get();
+ if (referent == null) {
+ return false;
+ }
+ Name otherReferent = ((RealKey) obj).get();
+ if (otherReferent == null) {
+ return false;
+ }
+ return Arrays.equals(referent.data, otherReferent.data);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return hashCode;
+ }
+
+ @Override
+ public String toString() {
+ Name referent = get();
+ return "RealKey(" + referent + ")";
+ }
+ }
+
+ private final ConcurrentMap map = new MapMaker().makeMap();
+ private final ReferenceQueue queue = new ReferenceQueue();
+
+ /**
+ * Return the Name corresponding to the data. An internal reference to
+ * data may be kept.
+ */
+ public Name of(char[] data) {
+ cleanUp();
+ int hashCode = Name.computeHashCode(data, 0, data.length);
+ FakeKey fakeKey = new FakeKey(data, hashCode);
+ Name result = get(fakeKey);
+ if (result == null) {
+ result = put(new Name(data, hashCode));
+ }
+ return result;
+ }
+
+ /**
+ * Return the Name corresponding to the data. An internal copy of the data is
+ * made.
+ */
+ public Name of(char[] data, int offset, int length) {
+ cleanUp();
+ int hashCode = Name.computeHashCode(data, offset, length);
+ FakeKey fakeKey = new FakeKey(data, offset, length, hashCode);
+ Name result = get(fakeKey);
+ if (result == null) {
+ char[] copy = new char[length];
+ System.arraycopy(data, offset, copy, 0, length);
+ result = put(new Name(copy, hashCode));
+ }
+ return result;
+ }
+
+ @VisibleForTesting
+ void cleanUp() {
+ RealKey item;
+ while ((item = (RealKey) queue.poll()) != null) {
+ map.remove(item);
+ }
+ }
+
+ @VisibleForTesting
+ WeakReference getRefFor(Name name) {
+ return map.get(new FakeKey(name.data, name.hashCode()));
+ }
+
+ @VisibleForTesting
+ int numEntries() {
+ return map.size();
+ }
+
+ private Name get(FakeKey fakeKey) {
+ RealKey realKey = map.get(fakeKey);
+ if (realKey != null) {
+ return realKey.get();
+ }
+ return null;
+ }
+
+ private Name put(Name name) {
+ RealKey realKey = new RealKey(name, queue);
+ while (true) {
+ RealKey sneakyRef = map.putIfAbsent(realKey, realKey);
+ if (sneakyRef == null) {
+ return name;
+ } else {
+ Name canonical = sneakyRef.get();
+ if (canonical != null) {
+ return canonical;
+ }
+ }
+ }
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/common/SourceInfo.java b/js/js.ast/src/com/google/dart/compiler/common/SourceInfo.java
new file mode 100644
index 00000000000..3a5cd23f113
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/common/SourceInfo.java
@@ -0,0 +1,58 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.common;
+import com.google.dart.compiler.Source;
+
+import java.io.Serializable;
+
+/**
+ * Tracks file and line information for AST nodes.
+ */
+public interface SourceInfo extends Serializable {
+
+ /**
+ * The source code provider.
+ */
+ Source getSource();
+
+ /**
+ * @return A 1-based line number into the original source file indicating
+ * where the source fragment begins.
+ */
+ int getSourceLine();
+
+ /**
+ * @return A 1-based column number into the original source file indicating
+ * where the source fragment begins.
+ */
+ int getSourceColumn();
+
+ /**
+ * Returns the character index into the original source file indicating
+ * where the source fragment corresponding to this node begins.
+ *
+ *
+ * The parser supplies useful well-defined source ranges to the nodes it creates.
+ *
+ * @return the 0-based character index, or -1
+ * if no source startPosition information is recorded for this node
+ * @see #getSourceLength()
+ * @see HasSourceInfo#setSourceLocation(com.google.dart.compiler.Source, int, int, int, int)
+ */
+ int getSourceStart();
+
+ /**
+ * Returns the length in characters of the original source file indicating
+ * where the source fragment corresponding to this node ends.
+ *
+ * The parser supplies useful well-defined source ranges to the nodes it creates.
+ *
+ * @return a (possibly 0) length, or 0
+ * if no source source position information is recorded for this node
+ * @see #getSourceStart()
+ * @see HasSourceInfo#setSourceLocation(com.google.dart.compiler.Source, int, int, int, int)
+ */
+ int getSourceLength();
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/util/AbstractTextOutput.java b/js/js.ast/src/com/google/dart/compiler/util/AbstractTextOutput.java
new file mode 100644
index 00000000000..9c8d2b1cd16
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/util/AbstractTextOutput.java
@@ -0,0 +1,132 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.util;
+
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+/**
+ * An abstract base type to build TextOutput implementations.
+ */
+public abstract class AbstractTextOutput implements TextOutput {
+ private final boolean compact;
+ private int identLevel = 0;
+ private int indentGranularity = 2;
+ private char[][] indents = new char[][] {new char[0]};
+ private boolean justNewlined;
+ private PrintWriter out;
+ private int position = 0;
+ private int line = 0;
+ private int column = 0;
+
+ protected AbstractTextOutput(boolean compact) {
+ this.compact = compact;
+ }
+
+ public int getPosition() {
+ return position;
+ }
+
+ public int getLine() {
+ return line;
+ }
+
+ public int getColumn() {
+ return column;
+ }
+
+ public void indentIn() {
+ ++identLevel;
+ if (identLevel >= indents.length) {
+ // Cache a new level of indentation string.
+ //
+ char[] newIndentLevel = new char[identLevel * indentGranularity];
+ Arrays.fill(newIndentLevel, ' ');
+ char[][] newIndents = new char[indents.length + 1][];
+ System.arraycopy(indents, 0, newIndents, 0, indents.length);
+ newIndents[identLevel] = newIndentLevel;
+ indents = newIndents;
+ }
+ }
+
+ public void indentOut() {
+ --identLevel;
+ }
+
+ public void newline() {
+ out.print('\n');
+ position++;
+ line++;
+ column = 0;
+ justNewlined = true;
+ }
+
+ public void newlineOpt() {
+ if (!compact) {
+ newline();
+ }
+ }
+
+ public void print(char c) {
+ maybeIndent();
+ out.print(c);
+ position++;
+ column++;
+ justNewlined = false;
+ }
+
+ public void print(char[] s) {
+ maybeIndent();
+ printAndCount(s);
+ justNewlined = false;
+ }
+
+ public void print(String s) {
+ maybeIndent();
+ printAndCount(s.toCharArray());
+ justNewlined = false;
+ }
+
+ // Why don't the "Opt" methods update "justNewLined"?
+ public void printOpt(char c) {
+ if (!compact) {
+ maybeIndent();
+ out.print(c);
+ position += 1;
+ column++;
+ }
+ }
+
+ public void printOpt(char[] s) {
+ if (!compact) {
+ maybeIndent();
+ printAndCount(s);
+ }
+ }
+
+ public void printOpt(String s) {
+ if (!compact) {
+ maybeIndent();
+ printAndCount(s.toCharArray());
+ }
+ }
+
+ protected void setPrintWriter(PrintWriter out) {
+ this.out = out;
+ }
+
+ private void maybeIndent() {
+ if (justNewlined && !compact) {
+ printAndCount(indents[identLevel]);
+ justNewlined = false;
+ }
+ }
+
+ private void printAndCount(char[] chars) {
+ position += chars.length;
+ column += chars.length;
+ out.print(chars);
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/util/AstUtil.java b/js/js.ast/src/com/google/dart/compiler/util/AstUtil.java
new file mode 100644
index 00000000000..c635d696c54
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/util/AstUtil.java
@@ -0,0 +1,404 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.util;
+
+import com.google.dart.compiler.InternalCompilerException;
+import com.google.dart.compiler.backend.js.ast.*;
+import com.google.dart.compiler.common.SourceInfo;
+import com.sun.istack.internal.NotNull;
+
+import java.util.List;
+
+/**
+ * @author johnlenz@google.com (John Lenz)
+ */
+public class AstUtil {
+
+ public static JsInvocation newInvocation(
+ JsExpression target, JsExpression... params) {
+ JsInvocation invoke = new JsInvocation();
+ invoke.setQualifier(target);
+ for (JsExpression expr : params) {
+ invoke.getArguments().add(expr);
+ }
+ return invoke;
+ }
+
+ public static JsInvocation newInvocation(
+ JsExpression target, List params) {
+ JsInvocation invoke = new JsInvocation();
+ invoke.setQualifier(target);
+ for (JsExpression expr : params) {
+ invoke.getArguments().add(expr);
+ }
+ return invoke;
+ }
+
+ public static JsNameRef newQualifiedNameRef(String name) {
+ JsNameRef node = null;
+ int endPos = -1;
+ int startPos = 0;
+ do {
+ endPos = name.indexOf('.', startPos);
+ String part = (endPos == -1
+ ? name.substring(startPos)
+ : name.substring(startPos, endPos));
+ node = newNameRef(node, part);
+ startPos = endPos + 1;
+ } while (endPos != -1);
+
+ return node;
+ }
+
+ public static JsNameRef newNameRef(JsExpression qualifier, String prop) {
+ JsNameRef nameRef = new JsNameRef(prop);
+ if (qualifier != null) {
+ nameRef.setQualifier(qualifier);
+ }
+ return nameRef;
+ }
+
+ public static JsNameRef nameref(SourceInfo info, JsName qualifier, JsName prop) {
+ JsNameRef nameRef = new JsNameRef(prop);
+ if (qualifier != null) {
+ nameRef.setQualifier(qualifier.makeRef());
+ }
+ nameRef.setSourceRef(info);
+ return nameRef;
+ }
+
+ public static JsNameRef newNameRef(JsExpression qualifier, JsName prop) {
+ JsNameRef nameRef = new JsNameRef(prop);
+ if (qualifier != null) {
+ nameRef.setQualifier(qualifier);
+ }
+ return nameRef;
+ }
+
+ public static JsNameRef newPrototypeNameRef(JsExpression qualifier) {
+ return newNameRef(qualifier, "prototype");
+ }
+
+ public static JsArrayAccess newArrayAccess(JsExpression target, JsExpression key) {
+ JsArrayAccess arr = new JsArrayAccess();
+ arr.setArrayExpr(target);
+ arr.setIndexExpr(key);
+ return arr;
+ }
+
+ public static JsBlock newBlock(JsStatement... stmts) {
+ JsBlock jsBlock = new JsBlock();
+ for (JsStatement stmt : stmts) {
+ jsBlock.getStatements().add(stmt);
+ }
+ return jsBlock;
+ }
+
+ /**
+ * Returns a sequence of expressions (using the binary sequence operator).
+ *
+ * @param exprs - expressions to add to sequence
+ * @return a sequence of expressions.
+ */
+ public static JsBinaryOperation newSequence(JsExpression... exprs) {
+ if (exprs.length < 2) {
+ throw new InternalCompilerException("newSequence expects at least two arguments");
+ }
+ JsExpression result = exprs[exprs.length - 1];
+ for (int i = exprs.length - 2; i >= 0; i--) {
+ result = new JsBinaryOperation(JsBinaryOperator.COMMA, exprs[i], result);
+ }
+ return (JsBinaryOperation) result;
+ }
+
+ // Ensure a valid LHS
+ public static JsBinaryOperation newAssignment(
+ JsNameRef nameRef, JsExpression expr) {
+ return new JsBinaryOperation(JsBinaryOperator.ASG, nameRef, expr);
+ }
+
+ public static JsBinaryOperation newAssignment(
+ JsArrayAccess target, JsExpression expr) {
+ return new JsBinaryOperation(JsBinaryOperator.ASG, target, expr);
+ }
+
+ public static JsVars newVar(SourceInfo info, JsName name, JsExpression expr) {
+ JsVars.JsVar var = new JsVars.JsVar(name).setSourceRef(info);
+ var.setInitExpr(expr);
+ JsVars vars = new JsVars();
+ vars.add(var);
+ return vars;
+ }
+
+ public static JsVars newVar(JsName name, JsExpression expr) {
+ JsVars.JsVar var = new JsVars.JsVar(name);
+ if (expr != null) {
+ var.setInitExpr(expr);
+ }
+ JsVars vars = new JsVars();
+ vars.add(var);
+ return vars;
+ }
+
+ public static JsSwitch newSwitch(
+ JsExpression expr, JsSwitchMember... cases) {
+ JsSwitch jsSwitch = new JsSwitch();
+ jsSwitch.setExpr(expr);
+ for (JsSwitchMember jsCase : cases) {
+ jsSwitch.getCases().add(jsCase);
+ }
+ return jsSwitch;
+ }
+
+ public static JsCase newCase(JsExpression expr, JsStatement... stmts) {
+ JsCase jsCase = new JsCase();
+ jsCase.setCaseExpr(expr);
+ for (JsStatement stmt : stmts) {
+ jsCase.getStmts().add(stmt);
+ }
+ return jsCase;
+ }
+
+ public static JsDefault newDefaultCase(JsStatement... stmts) {
+ JsDefault jsCase = new JsDefault();
+ for (JsStatement stmt : stmts) {
+ jsCase.getStmts().add(stmt);
+ }
+ return jsCase;
+ }
+
+ public static JsFunction newFunction(
+ JsScope scope, JsName name, List params, JsBlock body) {
+ JsFunction fn = new JsFunction(scope);
+ if (name != null) {
+ fn.setName(name);
+ }
+ if (params != null) {
+ for (JsParameter param : params) {
+ fn.getParameters().add(param);
+ }
+ }
+ fn.setBody(body);
+ return fn;
+ }
+
+ public static JsInvocation call(SourceInfo src, JsExpression target, JsExpression... params) {
+ return (JsInvocation) newInvocation(target, params).setSourceRef(src);
+ }
+
+ public static JsBinaryOperation comma(SourceInfo src, JsExpression op1, JsExpression op2) {
+ return (JsBinaryOperation) new JsBinaryOperation(JsBinaryOperator.COMMA, op1, op2)
+ .setSourceRef(src);
+ }
+
+ public static JsNameRef nameref(SourceInfo src, String name) {
+ return (JsNameRef) new JsNameRef(name).setSourceRef(src);
+ }
+
+ public static JsNameRef nameref(SourceInfo src, JsName qualifier, String prop) {
+ return nameref(src, qualifier.makeRef().setSourceRef(src), prop);
+ }
+
+ public static JsNameRef nameref(SourceInfo src, JsExpression qualifier, String prop) {
+ return (JsNameRef) newNameRef(qualifier, prop).setSourceRef(src);
+ }
+
+ public static JsExpression assign(SourceInfo src, JsNameRef op1, JsExpression op2) {
+ return newAssignment(op1, op2).setSourceRef(src);
+ }
+
+ public static JsExpression neq(SourceInfo src, JsExpression op1, JsExpression op2) {
+ return new JsBinaryOperation(JsBinaryOperator.NEQ, op1, op2).setSourceRef(src);
+ }
+
+ public static JsExpression not(SourceInfo src, JsExpression op1) {
+ return new JsPrefixOperation(JsUnaryOperator.NOT, op1).setSourceRef(src);
+ }
+
+ public static JsExpression preinc(SourceInfo src, JsExpression op1) {
+ return new JsPrefixOperation(JsUnaryOperator.INC, op1).setSourceRef(src);
+ }
+
+ public static JsExpression and(SourceInfo src, JsExpression op1, JsExpression op2) {
+ return new JsBinaryOperation(JsBinaryOperator.AND, op1, op2).setSourceRef(src);
+ }
+
+ public static JsExpression in(SourceInfo src, JsExpression propName, JsExpression obj) {
+ return new JsBinaryOperation(JsBinaryOperator.INOP, propName, obj).setSourceRef(src);
+ }
+
+
+ // Pavel Talanov
+ public static JsPropertyInitializer newNamedMethod(JsName name, JsFunction function) {
+ JsNameRef methodName = name.makeRef();
+ return new JsPropertyInitializer(methodName, function);
+ }
+
+ public static JsStatement convertToStatement(JsNode jsNode) {
+ assert (jsNode instanceof JsExpression) || (jsNode instanceof JsStatement)
+ : "Unexpected node of type: " + jsNode.getClass().toString();
+ if (jsNode instanceof JsExpression) {
+ return new JsExprStmt((JsExpression) jsNode);
+ }
+ return (JsStatement) jsNode;
+ }
+
+ public static JsBlock convertToBlock(JsNode jsNode) {
+ if (jsNode instanceof JsBlock) {
+ return (JsBlock) jsNode;
+ }
+ JsStatement jsStatement = convertToStatement(jsNode);
+ return new JsBlock(jsStatement);
+ }
+
+ public static JsExpression convertToExpression(JsNode jsNode) {
+ assert jsNode instanceof JsExpression : "Unexpected node of type: " + jsNode.getClass().toString();
+ return (JsExpression) jsNode;
+ }
+
+ public static JsNameRef thisQualifiedReference(JsName name) {
+ JsNameRef result = name.makeRef();
+ result.setQualifier(new JsThisRef());
+ return result;
+ }
+
+ public static JsBlock newBlock(List statements) {
+ JsBlock result = new JsBlock();
+ result.setStatements(statements);
+ return result;
+ }
+
+ public static JsPrefixOperation negated(JsExpression expression) {
+ return new JsPrefixOperation(JsUnaryOperator.NOT, expression);
+ }
+
+ public static JsStatement newAssignmentStatement(JsNameRef nameRef, JsExpression expr) {
+ return convertToStatement(new JsBinaryOperation(JsBinaryOperator.ASG, nameRef, expr));
+ }
+
+ public static JsExpression extractExpressionFromStatement(JsStatement statement) {
+ assert statement instanceof JsExprStmt : "Cannot extract expression from statement: " + statement;
+ return (((JsExprStmt) statement).getExpression());
+ }
+
+ public static JsBinaryOperation and(JsExpression op1, JsExpression op2) {
+ return new JsBinaryOperation(JsBinaryOperator.AND, op1, op2);
+ }
+
+ public static JsBinaryOperation or(JsExpression op1, JsExpression op2) {
+ return new JsBinaryOperation(JsBinaryOperator.OR, op1, op2);
+ }
+
+ //TODO refactor
+ public static void setQualifier(JsExpression selector, JsExpression receiver) {
+ if (selector instanceof JsInvocation) {
+ setQualifier(((JsInvocation) selector).getQualifier(), receiver);
+ return;
+ }
+ if (selector instanceof JsNameRef) {
+ JsNameRef nameRef = (JsNameRef) selector;
+ JsExpression qualifier = nameRef.getQualifier();
+ if (qualifier == null) {
+ nameRef.setQualifier(receiver);
+ } else {
+ setQualifier(qualifier, receiver);
+ }
+ return;
+ }
+ throw new AssertionError("Set qualifier should be applied only to JsInvocation or JsNameRef instances");
+ }
+
+ //TODO: look for should-be-usages
+ public static JsNameRef qualified(JsName selector, JsExpression qualifier) {
+ JsNameRef reference = selector.makeRef();
+ AstUtil.setQualifier(reference, qualifier);
+ return reference;
+ }
+
+ public static JsBinaryOperation equals(JsExpression arg1, JsExpression arg2) {
+ return new JsBinaryOperation(JsBinaryOperator.EQ, arg1, arg2);
+ }
+
+ public static JsBinaryOperation notEqual(JsExpression arg1, JsExpression arg2) {
+ return new JsBinaryOperation(JsBinaryOperator.NEQ, arg1, arg2);
+ }
+
+ public static JsExpression equalsTrue(JsExpression expression, JsProgram program) {
+ return equals(expression, program.getTrueLiteral());
+ }
+
+ public static JsExpression assignment(JsExpression left, JsExpression right) {
+ return new JsBinaryOperation(JsBinaryOperator.ASG, left, right);
+ }
+
+ public static JsBinaryOperation sum(JsExpression left, JsExpression right) {
+ return new JsBinaryOperation(JsBinaryOperator.ADD, left, right);
+ }
+
+ public static JsBinaryOperation subtract(JsExpression left, JsExpression right) {
+ return new JsBinaryOperation(JsBinaryOperator.SUB, left, right);
+ }
+
+ public static JsPrefixOperation not(JsExpression expression) {
+ return new JsPrefixOperation(JsUnaryOperator.NOT, expression);
+ }
+
+ public static JsBinaryOperation typeof(JsExpression expression, JsStringLiteral string) {
+ return equals(new JsPrefixOperation(JsUnaryOperator.TYPEOF, expression), string);
+ }
+
+ public static interface Mutator {
+ public JsNode mutate(JsNode node);
+ }
+
+
+ //TODO: move somewhere
+ //TODO: refactor and review
+ public static JsNode mutateLastExpression(JsNode node, Mutator mutator) {
+ if (node instanceof JsBlock) {
+ JsBlock block = (JsBlock) node;
+ List statements = block.getStatements();
+
+ if (statements.isEmpty()) return block;
+
+ int size = statements.size();
+ statements.set(size - 1,
+ AstUtil.convertToStatement(mutateLastExpression(statements.get(size - 1), mutator)));
+ return block;
+ }
+ if (node instanceof JsIf) {
+ JsIf ifExpr = (JsIf) node;
+ ifExpr.setThenStmt(AstUtil.convertToStatement(mutateLastExpression(ifExpr.getThenStmt(), mutator)));
+ JsStatement elseStmt = ifExpr.getElseStmt();
+ if (elseStmt != null) {
+ ifExpr.setElseStmt(AstUtil.convertToStatement(mutateLastExpression(elseStmt, mutator)));
+ }
+ return ifExpr;
+ }
+ if (node instanceof JsExprStmt) {
+ return AstUtil.convertToStatement(mutateLastExpression(((JsExprStmt) node).getExpression(), mutator));
+ }
+ return mutator.mutate(node);
+ }
+
+
+ public static final class SaveLastExpressionMutator implements Mutator {
+
+ @NotNull
+ private final JsExpression toAssign;
+
+ public SaveLastExpressionMutator(@NotNull JsExpression toAssign) {
+ this.toAssign = toAssign;
+ }
+
+ @Override
+ public JsNode mutate(JsNode node) {
+ if (!(node instanceof JsExpression)) {
+ return node;
+ }
+ return AstUtil.assignment(toAssign, (JsExpression) node);
+ }
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/util/DefaultTextOutput.java b/js/js.ast/src/com/google/dart/compiler/util/DefaultTextOutput.java
new file mode 100644
index 00000000000..2a064ff87fd
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/util/DefaultTextOutput.java
@@ -0,0 +1,32 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.util;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+/**
+ * Adapts {@link TextOutput} to an internal text buffer.
+ */
+public class DefaultTextOutput extends AbstractTextOutput {
+
+ private final StringWriter sw = new StringWriter();
+ private final PrintWriter out;
+
+ public DefaultTextOutput(boolean compact) {
+ super(compact);
+ setPrintWriter(out = new PrintWriter(sw));
+ }
+
+ @Override
+ public String toString() {
+ out.flush();
+ if (sw != null) {
+ return sw.toString();
+ } else {
+ return super.toString();
+ }
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/util/Hack.java b/js/js.ast/src/com/google/dart/compiler/util/Hack.java
new file mode 100644
index 00000000000..642f416394f
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/util/Hack.java
@@ -0,0 +1,16 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.util;
+
+/**
+ * Utility to hack around untypable (or yet to be) code.
+ */
+public class Hack {
+ public static T cast(Object o) {
+ @SuppressWarnings("unchecked")
+ T t = (T) o;
+ return t;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/util/Lists.java b/js/js.ast/src/com/google/dart/compiler/util/Lists.java
new file mode 100644
index 00000000000..b0ca023d280
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/util/Lists.java
@@ -0,0 +1,291 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.util;
+
+import java.util.*;
+
+/**
+ * Utility methods for operating on memory-efficient lists. All lists of size 0
+ * or 1 are assumed to be immutable. All lists of size greater than 1 are
+ * assumed to be mutable.
+ */
+public class Lists {
+
+ private static final Class MULTI_LIST_CLASS = ArrayList.class;
+ private static final Class SINGLETON_LIST_CLASS = Collections.singletonList(null).getClass();
+
+ public static List add(List list, int index, T toAdd) {
+ switch (list.size()) {
+ case 0:
+ // Empty -> Singleton
+ if (index != 0) {
+ throw newIndexOutOfBounds(list, index);
+ }
+ return Collections.singletonList(toAdd);
+ case 1: {
+ // Singleton -> ArrayList
+ List result = new ArrayList(2);
+ switch (index) {
+ case 0:
+ result.add(toAdd);
+ result.add(list.get(0));
+ return result;
+ case 1:
+ result.add(list.get(0));
+ result.add(toAdd);
+ return result;
+ default:
+ throw newIndexOutOfBounds(list, index);
+ }
+ }
+ default:
+ // ArrayList
+ list.add(index, toAdd);
+ return list;
+ }
+ }
+
+ public static List add(List list, T toAdd) {
+ switch (list.size()) {
+ case 0:
+ // Empty -> Singleton
+ return Collections.singletonList(toAdd);
+ case 1: {
+ // Singleton -> ArrayList
+ List result = new ArrayList(2);
+ result.add(list.get(0));
+ result.add(toAdd);
+ return result;
+ }
+ default:
+ // ArrayList
+ list.add(toAdd);
+ return list;
+ }
+ }
+
+ public static List addAll(List list, int index, List toAdd) {
+ switch (toAdd.size()) {
+ case 0:
+ // No-op.
+ return list;
+ case 1:
+ // Add one element.
+ return add(list, index, toAdd.get(0));
+ default:
+ // True list merge, result >= 2.
+ switch (list.size()) {
+ case 0:
+ if (index != 0) {
+ throw newIndexOutOfBounds(list, index);
+ }
+ return new ArrayList(toAdd);
+ case 1: {
+ List result = new ArrayList(1 + toAdd.size());
+ switch (index) {
+ case 0:
+ result.addAll(toAdd);
+ result.add(list.get(0));
+ return result;
+ case 1:
+ result.add(list.get(0));
+ result.addAll(toAdd);
+ return result;
+ default:
+ throw newIndexOutOfBounds(list, index);
+ }
+ }
+ default:
+ list.addAll(index, toAdd);
+ return list;
+ }
+ }
+ }
+
+ public static List addAll(List list, List toAdd) {
+ switch (toAdd.size()) {
+ case 0:
+ // No-op.
+ return list;
+ case 1:
+ // Add one element.
+ return add(list, toAdd.get(0));
+ default:
+ // True list merge, result >= 2.
+ switch (list.size()) {
+ case 0:
+ return new ArrayList(toAdd);
+ case 1: {
+ List result = new ArrayList(1 + toAdd.size());
+ result.add(list.get(0));
+ result.addAll(toAdd);
+ return result;
+ }
+ default:
+ list.addAll(toAdd);
+ return list;
+ }
+ }
+ }
+
+ public static List addAll(List list, T... toAdd) {
+ switch (toAdd.length) {
+ case 0:
+ // No-op.
+ return list;
+ case 1:
+ // Add one element.
+ return add(list, toAdd[0]);
+ default:
+ // True list merge, result >= 2.
+ switch (list.size()) {
+ case 0:
+ return new ArrayList(Arrays.asList(toAdd));
+ case 1: {
+ List result = new ArrayList(1 + toAdd.length);
+ result.add(list.get(0));
+ result.addAll(Arrays.asList(toAdd));
+ return result;
+ }
+ default:
+ list.addAll(Arrays.asList(toAdd));
+ return list;
+ }
+ }
+ }
+
+ public static List create() {
+ return Collections.emptyList();
+ }
+
+ public static List create(Collection collection) {
+ switch (collection.size()) {
+ case 0:
+ return create();
+ default:
+ return new ArrayList(collection);
+ }
+ }
+
+ public static List create(List list) {
+ switch (list.size()) {
+ case 0:
+ return create();
+ case 1:
+ return create(list.get(0));
+ default:
+ return new ArrayList(list);
+ }
+ }
+
+ public static List create(T item) {
+ return Collections.singletonList(item);
+ }
+
+ public static List create(T... items) {
+ switch (items.length) {
+ case 0:
+ return create();
+ case 1:
+ return create(items[0]);
+ default:
+ return new ArrayList(Arrays.asList(items));
+ }
+ }
+
+ public static List normalize(List list) {
+ switch (list.size()) {
+ case 0:
+ return create();
+ case 1: {
+ if (list.getClass() == SINGLETON_LIST_CLASS) {
+ return list;
+ }
+ return create(list.get(0));
+ }
+ default:
+ if (list.getClass() == MULTI_LIST_CLASS) {
+ return list;
+ }
+ return new ArrayList(list);
+ }
+ }
+
+ public static List normalizeUnmodifiable(List list) {
+ if (list.size() < 2) {
+ return normalize(list);
+ } else {
+ List copy = new ArrayList(list.size());
+ Collections.copy(copy, list);
+ return copy;
+ }
+ }
+
+ public static List remove(List list, int toRemove) {
+ switch (list.size()) {
+ case 0:
+ // Empty
+ throw newIndexOutOfBounds(list, toRemove);
+ case 1:
+ // Singleton -> Empty
+ if (toRemove == 0) {
+ return Collections.emptyList();
+ } else {
+ throw newIndexOutOfBounds(list, toRemove);
+ }
+ case 2:
+ // ArrayList -> Singleton
+ switch (toRemove) {
+ case 0:
+ return Collections.singletonList(list.get(1));
+ case 1:
+ return Collections.singletonList(list.get(0));
+ default:
+ throw newIndexOutOfBounds(list, toRemove);
+ }
+ default:
+ // ArrayList
+ list.remove(toRemove);
+ return list;
+ }
+ }
+
+ public static List set(List list, int index, T e) {
+ switch (list.size()) {
+ case 0:
+ // Empty
+ throw newIndexOutOfBounds(list, index);
+ case 1:
+ // Singleton
+ if (index == 0) {
+ return Collections.singletonList(e);
+ } else {
+ throw newIndexOutOfBounds(list, index);
+ }
+ default:
+ // ArrayList
+ list.set(index, e);
+ return list;
+ }
+ }
+
+ public static > List sort(List list) {
+ if (list.size() > 1) {
+ Collections.sort(list);
+ }
+ return list;
+ }
+
+ public static List sort(List list, Comparator sort) {
+ if (list.size() > 1) {
+ Collections.sort(list, sort);
+ }
+ return list;
+ }
+
+ private static IndexOutOfBoundsException newIndexOutOfBounds(List list, int index) {
+ return new IndexOutOfBoundsException("Index: " + index + ", Size: " + list.size());
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/util/Maps.java b/js/js.ast/src/com/google/dart/compiler/util/Maps.java
new file mode 100644
index 00000000000..15274b04902
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/util/Maps.java
@@ -0,0 +1,160 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.util;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Utility methods for operating on memory-efficient maps. All maps of size 0 or
+ * 1 are assumed to be immutable. All maps of size greater than 1 are assumed to
+ * be mutable.
+ */
+public class Maps {
+
+ private static final Class MULTI_MAP_CLASS = HashMap.class;
+ private static final Class SINGLETON_MAP_CLASS =
+ Collections.singletonMap(null, null).getClass();
+
+ public static Map create() {
+ return Collections.emptyMap();
+ }
+
+ public static Map create(K key, V value) {
+ return Collections.singletonMap(key, value);
+ }
+
+ public static Map normalize(Map map) {
+ switch (map.size()) {
+ case 0:
+ return create();
+ case 1: {
+ if (map.getClass() == SINGLETON_MAP_CLASS) {
+ return map;
+ }
+ K key = map.keySet().iterator().next();
+ return create(key, map.get(key));
+ }
+ default:
+ if (map.getClass() == MULTI_MAP_CLASS) {
+ return map;
+ }
+ return new HashMap(map);
+ }
+ }
+
+ public static Map normalizeUnmodifiable(Map map) {
+ if (map.size() < 2) {
+ return normalize(map);
+ } else {
+ // TODO: implement an UnmodifiableHashMap?
+ return Collections.unmodifiableMap(normalize(map));
+ }
+ }
+
+ public static Map put(Map map, K key, V value) {
+ switch (map.size()) {
+ case 0:
+ // Empty -> Singleton
+ return Collections.singletonMap(key, value);
+ case 1: {
+ if (map.containsKey(key)) {
+ return create(key, value);
+ }
+ // Singleton -> HashMap
+ Map result = new HashMap();
+ result.put(map.keySet().iterator().next(), map.values().iterator().next());
+ result.put(key, value);
+ return result;
+ }
+ default:
+ // HashMap
+ map.put(key, value);
+ return map;
+ }
+ }
+
+ public static Map putAll(Map map, Map toAdd) {
+ switch (toAdd.size()) {
+ case 0:
+ // No-op.
+ return map;
+ case 1: {
+ // Add one element.
+ K key = toAdd.keySet().iterator().next();
+ return put(map, key, toAdd.get(key));
+ }
+ default:
+ // True list merge, result >= 2.
+ switch (map.size()) {
+ case 0:
+ return new HashMap(toAdd);
+ case 1: {
+ HashMap result = new HashMap();
+ K key = map.keySet().iterator().next();
+ result.put(key, map.get(key));
+ result.putAll(toAdd);
+ return result;
+ }
+ default:
+ map.putAll(toAdd);
+ return map;
+ }
+ }
+ }
+
+ /**
+ * A variation of the put method which uses a LinkedHashMap.
+ */
+ public static Map putOrdered(Map map, K key, V value) {
+ switch (map.size()) {
+ case 0:
+ // Empty -> Singleton
+ return Collections.singletonMap(key, value);
+ case 1: {
+ if (map.containsKey(key)) {
+ return create(key, value);
+ }
+ // Singleton -> LinkedHashMap
+ Map result = new LinkedHashMap();
+ result.put(map.keySet().iterator().next(), map.values().iterator().next());
+ result.put(key, value);
+ return result;
+ }
+ default:
+ // LinkedHashMap
+ map.put(key, value);
+ return map;
+ }
+ }
+
+ public static Map remove(Map map, K key) {
+ switch (map.size()) {
+ case 0:
+ // Empty
+ return map;
+ case 1:
+ // Singleton -> Empty
+ if (map.containsKey(key)) {
+ return create();
+ }
+ return map;
+ case 2:
+ // HashMap -> Singleton
+ if (map.containsKey(key)) {
+ map.remove(key);
+ key = map.keySet().iterator().next();
+ return create(key, map.get(key));
+ }
+ return map;
+ default:
+ // IdentityHashMap
+ map.remove(key);
+ return map;
+ }
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/util/Paths.java b/js/js.ast/src/com/google/dart/compiler/util/Paths.java
new file mode 100644
index 00000000000..cdda910ccb1
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/util/Paths.java
@@ -0,0 +1,100 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.util;
+
+import java.io.File;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Utility methods for obtaining relative paths from files and translating
+ * relative paths into files.
+ */
+public class Paths {
+
+ /**
+ * Answer the relative path from baseFile to relFile
+ *
+ * @param baseFile the base file (not null) from which the
+ * desired path starts
+ * @param relFile the file referenced by the desired relative path (not
+ * null)
+ * @return a relative path (not null)
+ */
+ public static String relativePathFor(File baseFile, File relFile) {
+ String baseFilePath = baseFile.getPath().replace(File.separatorChar, '/');
+ String relFilePath = relFile.getPath().replace(File.separatorChar, '/');
+ int baseFilePathLen = baseFilePath.length();
+ int relFilePathLen = relFilePath.length();
+
+ // Find the com.google.dart.compiler.backend.common path elements
+ int index = 0;
+ while (index < baseFilePathLen - 1 && index < relFilePathLen - 1) {
+ if (baseFilePath.charAt(index) != relFilePath.charAt(index)) {
+ break;
+ }
+ index++;
+ }
+ while (index >= 0
+ && (baseFilePath.charAt(index) != '/' || relFilePath.charAt(index) != '/')) {
+ index--;
+ }
+ int commonStart = index;
+
+ // Build a path up from the base file
+ StringBuilder relPath = new StringBuilder(baseFilePathLen + relFilePathLen
+ - commonStart * 2);
+ index = commonStart + 1;
+ while (true) {
+ index = baseFilePath.indexOf('/', index);
+ if (index == -1) {
+ break;
+ }
+ relPath.append("../");
+ index++;
+ }
+ relPath.append(relFilePath.substring(commonStart + 1));
+ return relPath.toString();
+ }
+
+ /**
+ * Answer the file relative to the specified file
+ *
+ * @param baseFile the base file (not null)
+ * @param relPath the path to the desired file relative to baseFile
+ * @return the file (not null)
+ */
+ public static File relativePathToFile(File baseFile, String relPath) {
+ if (relPath.startsWith("/")) {
+ return new File(relPath);
+ }
+ File parentFile = baseFile.getParentFile();
+ String name;
+ if (parentFile == null) {
+ name = ".";
+ } else {
+ name = parentFile.getPath().replace(File.separatorChar, '/');
+ }
+ name = URI.create(name + "/" + relPath).normalize().getPath();
+ return new File(name);
+ }
+
+ /**
+ * Given a collection of paths, return a collection of files
+ *
+ * @param a collection of paths to various files (not null,
+ * contains no nulls)
+ * @return a collection of files (not null, contains no
+ * nulls)
+ */
+ public static List toFiles(List filePaths) {
+ List files = new ArrayList();
+ for (String path : filePaths) {
+ files.add(new File(path));
+ }
+ return files;
+ }
+}
diff --git a/js/js.ast/src/com/google/dart/compiler/util/TextOutput.java b/js/js.ast/src/com/google/dart/compiler/util/TextOutput.java
new file mode 100644
index 00000000000..99a465b1532
--- /dev/null
+++ b/js/js.ast/src/com/google/dart/compiler/util/TextOutput.java
@@ -0,0 +1,37 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.google.dart.compiler.util;
+
+/**
+ * Interface used for printing text output.
+ */
+public interface TextOutput {
+
+ int getPosition();
+
+ int getLine();
+
+ int getColumn();
+
+ void indentIn();
+
+ void indentOut();
+
+ void newline();
+
+ void newlineOpt();
+
+ void print(char c);
+
+ void print(char[] s);
+
+ void print(String s);
+
+ void printOpt(char c);
+
+ void printOpt(char[] s);
+
+ void printOpt(String s);
+}
diff --git a/js/js.backend/js.backend.iml b/js/js.backend/js.backend.iml
new file mode 100644
index 00000000000..6333c03551e
--- /dev/null
+++ b/js/js.backend/js.backend.iml
@@ -0,0 +1,26 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/js/js.backend/lib/asm-util-3.3.1.jar b/js/js.backend/lib/asm-util-3.3.1.jar
new file mode 100644
index 00000000000..0230bbcfb71
Binary files /dev/null and b/js/js.backend/lib/asm-util-3.3.1.jar differ
diff --git a/js/js.backend/lib/guava-10.0.1.jar b/js/js.backend/lib/guava-10.0.1.jar
new file mode 100644
index 00000000000..d107c0f3b0c
Binary files /dev/null and b/js/js.backend/lib/guava-10.0.1.jar differ
diff --git a/js/js.backend/lib/js.jar b/js/js.backend/lib/js.jar
new file mode 100644
index 00000000000..878b0d9422b
Binary files /dev/null and b/js/js.backend/lib/js.jar differ
diff --git a/js/js.backend/src/org/jetbrains/k2js/analyze/Analyzer.java b/js/js.backend/src/org/jetbrains/k2js/analyze/Analyzer.java
new file mode 100644
index 00000000000..d0aba16b5a6
--- /dev/null
+++ b/js/js.backend/src/org/jetbrains/k2js/analyze/Analyzer.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2000-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.k2js.analyze;
+
+import com.google.common.base.Predicate;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.Configuration;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
+import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.k2js.config.Config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Pavel Talanov
+ */
+public final class Analyzer {
+
+ private Analyzer() {
+ }
+
+ @NotNull
+ public static BindingContext analyzeFilesAndCheckErrors(@NotNull List files,
+ @NotNull Config config) {
+ BindingContext bindingContext = analyzeFiles(files, config);
+ checkForErrors(withJsLibAdded(files, config), bindingContext);
+ return bindingContext;
+ }
+
+ @NotNull
+ public static BindingContext analyzeFiles(@NotNull List files,
+ @NotNull Config config) {
+ Project project = config.getProject();
+ return AnalyzingUtils.analyzeFiles(project,
+ JsConfiguration.jsLibConfiguration(project),
+ withJsLibAdded(files, config),
+ notLibFiles(config.getLibFiles()),
+ JetControlFlowDataTraceFactory.EMPTY);
+ }
+
+ private static void checkForErrors(@NotNull List allFiles, @NotNull BindingContext bindingContext) {
+ AnalyzingUtils.throwExceptionOnErrors(bindingContext);
+ for (JetFile file : allFiles) {
+ AnalyzingUtils.checkForSyntacticErrors(file);
+ }
+ }
+
+ //TODO: use some mechanism to avoid this
+ //TODO: move method somewhere
+ @NotNull
+ public static List withJsLibAdded(@NotNull List files, @NotNull Config config) {
+ List allFiles = new ArrayList();
+ allFiles.addAll(files);
+ allFiles.addAll(config.getLibFiles());
+ return allFiles;
+ }
+
+ @NotNull
+ private static Predicate notLibFiles(@NotNull final List jsLibFiles) {
+ return new Predicate() {
+ @Override
+ public boolean apply(@Nullable PsiFile file) {
+ assert file instanceof JetFile;
+ @SuppressWarnings("UnnecessaryLocalVariable") boolean notLibFile = !jsLibFiles.contains(file);
+ return notLibFile;
+ }
+ };
+ }
+
+ private static final class JsConfiguration implements Configuration {
+
+ @NotNull
+ private Project project;
+
+ public static JsConfiguration jsLibConfiguration(@NotNull Project project) {
+ return new JsConfiguration(project);
+ }
+
+ private JsConfiguration(@NotNull Project project) {
+ this.project = project;
+ }
+
+ @Override
+ public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope,
+ @NotNull Importer importer) {
+ ImportsResolver.ImportResolver importResolver = new ImportsResolver.ImportResolver(trace, true);
+ importResolver.processImportReference(JetPsiFactory.createImportDirective(project, "js.*"), rootScope, importer);
+ }
+
+ @Override
+ public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor,
+ @NotNull WritableScope namespaceMemberScope) {
+ }
+ }
+}
diff --git a/js/js.backend/src/org/jetbrains/k2js/config/Config.java b/js/js.backend/src/org/jetbrains/k2js/config/Config.java
new file mode 100644
index 00000000000..9bef13e1220
--- /dev/null
+++ b/js/js.backend/src/org/jetbrains/k2js/config/Config.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2000-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.k2js.config;
+
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetFile;
+
+import java.util.List;
+
+/**
+ * @author Pavel Talanov
+ *
+ * Base class reprenting a configuration of translator.
+ */
+public abstract class Config {
+
+ @NotNull
+ public abstract Project getProject();
+
+ @NotNull
+ public abstract List getLibFiles();
+
+}
diff --git a/js/js.backend/src/org/jetbrains/k2js/config/IDEAConfig.java b/js/js.backend/src/org/jetbrains/k2js/config/IDEAConfig.java
new file mode 100644
index 00000000000..b421601c274
--- /dev/null
+++ b/js/js.backend/src/org/jetbrains/k2js/config/IDEAConfig.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2000-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.k2js.config;
+
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetFile;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Pavel Talanov
+ */
+public final class IDEAConfig extends Config {
+
+ @NotNull
+ private final Project project;
+
+ public IDEAConfig(@NotNull Project project) {
+ this.project = project;
+ }
+
+ @NotNull
+ @Override
+ public Project getProject() {
+ return project;
+ }
+
+ @NotNull
+ @Override
+ public List getLibFiles() {
+ return Collections.emptyList();
+ }
+}
diff --git a/js/js.backend/src/org/jetbrains/k2js/config/TestConfig.java b/js/js.backend/src/org/jetbrains/k2js/config/TestConfig.java
new file mode 100644
index 00000000000..68a91518455
--- /dev/null
+++ b/js/js.backend/src/org/jetbrains/k2js/config/TestConfig.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2000-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.k2js.config;
+
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.project.Project;
+import core.Dummy;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.compiler.JetCoreEnvironment;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.k2js.utils.JetFileUtils;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author Pavel Talanov
+ */
+//TODO: review/refactor
+public final class TestConfig extends Config {
+
+ //TODO: provide some generic way to get the files of the project
+ @NotNull
+ private static final List LIB_FILE_NAMES = Arrays.asList(
+ "/core/annotations.kt",
+ "/jquery/common.kt",
+ "/jquery/ui.kt",
+ "/core/javautil.kt",
+ "/core/javalang.kt",
+ "/core/core.kt",
+ "/core/math.kt",
+ "/core/json.kt",
+ "/raphael/raphael.kt",
+ "/html5/canvas.kt",
+ "/html5/files.kt",
+ "/html5/image.kt"
+ );
+
+ @NotNull
+ private static JetCoreEnvironment getTestEnvironment() {
+ if (testOnlyEnvironment == null) {
+ testOnlyEnvironment = new JetCoreEnvironment(new Disposable() {
+ @Override
+ public void dispose() {
+ }
+ });
+ }
+ return testOnlyEnvironment;
+ }
+
+ @Nullable
+ private static /*var*/ JetCoreEnvironment testOnlyEnvironment = null;
+
+
+ @Nullable
+ private /*var*/ List jsLibFiles = null;
+
+ public TestConfig() {
+ }
+
+ @NotNull
+ @Override
+ public Project getProject() {
+ return getTestEnvironment().getProject();
+ }
+
+ @NotNull
+ private static List