Updates dartc to recognize 'default' keyword on interface and updated factory method syntax

compiler/java/com/google/dart/compiler/backend/js/Normalizer.java

 // 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;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
 import com.google.common.collect.Lists;
 import com.google.dart.compiler.InternalCompilerException;
 import com.google.dart.compiler.ast.DartArrayAccess;
 import com.google.dart.compiler.ast.DartBinaryExpression;
 import com.google.dart.compiler.ast.DartBlock;
 import com.google.dart.compiler.ast.DartCase;
 import com.google.dart.compiler.ast.DartClass;
 import com.google.dart.compiler.ast.DartClassMember;
 import com.google.dart.compiler.ast.DartContext;
 import com.google.dart.compiler.ast.DartDefault;
@@ skipping 42 matching lines @@
 import com.google.dart.compiler.resolver.Elements;
 import com.google.dart.compiler.resolver.EnclosingElement;
 import com.google.dart.compiler.resolver.FieldElement;
 import com.google.dart.compiler.resolver.LabelElement;
 import com.google.dart.compiler.resolver.MethodElement;
 import com.google.dart.compiler.resolver.SyntheticDefaultConstructorElement;
 import com.google.dart.compiler.resolver.VariableElement;
 import com.google.dart.compiler.type.InterfaceType;
 import com.google.dart.compiler.type.Types;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
 /**
  * Normalization phase of Dart compiler. Rewrites the AST to simplify later
  * phases.
  * <ul>
  * <li>Split 'type' declarations such as "int a = 0, b = 0"
  * <li>Introduce block statements for control structures such as IF, WHILE, and
  *     FOR
  * <li>normalize case statements, including adding FallThroughError throws
  * <li>pull initializers out of FOR loops
  * <li>remove useless statement labels
@@ skipping 508 matching lines @@
       if (Elements.needsImplicitDefaultConstructor(classElement)) {
         DartMethodDefinition method = createImplicitDefaultConstructor(classElement);
         // TODO - We should really normalize the class itself.
         node.getMembers().add(method);
       }
       return super.visitClass(node);
     }
 
     private DartMethodDefinition createImplicitDefaultConstructor(final ClassElement classElement) {
       assert (Elements.needsImplicitDefaultConstructor(classElement));
-      DartFunction function = new DartFunction(Collections.<DartParameter>emptyList(), 
+      DartFunction function = new DartFunction(Collections.<DartParameter>emptyList(),
           new DartBlock(Collections.<DartStatement>emptyList()), null);
       final DartMethodDefinition method =
-          DartMethodDefinition.create(new DartIdentifier(""), function, Modifiers.NONE, null, null);
+          DartMethodDefinition.create(new DartIdentifier(""), function, Modifiers.NONE, null);
       method.setSymbol(new SyntheticDefaultConstructorElement(method, classElement, null));
       return method;
     }
 
     @Override
     public DartExpression visitBinaryExpression(DartBinaryExpression node) {
       node.visitChildren(this);
       Token operator = node.getOperator();
       if (operator.isAssignmentOperator() && operator != Token.ASSIGN
           && shouldNormalizeOperator(node)) {
@@ skipping 12 matching lines @@
         DartExpression lhs = node.getArg().getNormalizedNode();
         DartIntegerLiteral rhs = DartIntegerLiteral.one();
         node.setNormalizedNode(normalizeCompoundAssignment(mapAssignableOp(operator),
                                                            !node.isPrefix(), lhs, rhs));
       }
       return node;
     }
 
     static class NeedsImplicitSuperInvocationDeterminant extends DartNodeTraverser<Void> {
       private boolean needsSuperInvocation = true;
-      
+
       @Override
       public Void visitSuperConstructorInvocation(DartSuperConstructorInvocation node) {
         needsSuperInvocation = false;
         return super.visitSuperConstructorInvocation(node);
       }
-      
+
       @Override
       public Void visitRedirectConstructorInvocation(DartRedirectConstructorInvocation node) {
         needsSuperInvocation = false;
         return super.visitRedirectConstructorInvocation(node);
       }
-      
+
       @Override
       public Void visitMethodDefinition(DartMethodDefinition node) {
         // Ignore everything except the initializers
         for (DartInitializer initializer : node.getInitializers()) {
           initializer.accept(this);
         }
         return null;
       }
     }
 
     @Override
     public DartMethodDefinition visitMethodDefinition(DartMethodDefinition node) {
       super.visitMethodDefinition(node);
       if (Elements.isNonFactoryConstructor(node.getSymbol())) {
         normalizeParameterInitializer(node);
       }
-      
+
       return node;
     }
 
     @Override
     public DartNode visitNewExpression(DartNewExpression node) {
       ConstructorElement symbol = node.getSymbol();
       if (symbol == null) {
         InterfaceType constructorType = Types.constructorType(node);
         if (!constructorType.getElement().isDynamic() && node.getArgs().isEmpty()) {
           // HACK use proper normalized node
           ClassElement classToInstantiate = constructorType.getElement();
           if (classToInstantiate.getDefaultClass() != null) {
             classToInstantiate = classToInstantiate.getDefaultClass().getElement();
           }
 
           if (classToInstantiate != null
               && Elements.needsImplicitDefaultConstructor(classToInstantiate)) {
             DartMethodDefinition implicitDefaultConstructor =
                 createImplicitDefaultConstructor(classToInstantiate);
             node.setSymbol(implicitDefaultConstructor.getSymbol());
           }
         }
       }
-      
+
       return super.visitNewExpression(node);
     }
-    
+
     @Override
     public DartNode visitSwitchStatement(DartSwitchStatement node) {
       node.getExpression().accept(this);
       for (DartNode member : node.getMembers()) {
         member.accept(this);
       }
       return node;
     }
 
     // Normalize parameter initializer.
@@ skipping 23 matching lines @@
 
       EnclosingElement enclosingElement = node.getSymbol().getEnclosingElement();
       if (ElementKind.of(enclosingElement) == ElementKind.CLASS) {
         ClassElement classElement = (ClassElement) enclosingElement;
         if (!classElement.isObject()) {
           NeedsImplicitSuperInvocationDeterminant superLocator = new NeedsImplicitSuperInvocationDeterminant();
           node.accept(superLocator);
           if (superLocator.needsSuperInvocation) {
             DartSuperConstructorInvocation superInvocation = new DartSuperConstructorInvocation(
                 new DartIdentifier(""), Collections.<DartExpression>emptyList());
-            superInvocation.setSymbol(new SyntheticDefaultConstructorElement(null, 
+            superInvocation.setSymbol(new SyntheticDefaultConstructorElement(null,
                 classElement.getSupertype().getElement(), null));
             nInit.add(new DartInitializer(null, superInvocation));
-          }    
+          }
         }
       }
-      
+
       if (!nInit.isEmpty()) {
         if (!node.getInitializers().isEmpty()) {
           nInit.addAll(0, node.getInitializers());
         }
-        
+
         DartMethodDefinition nConstructor = DartMethodDefinition.create(
-                node.getName(), node.getFunction(), node.getModifiers(), nInit, null);
+                node.getName(), node.getFunction(), node.getModifiers(), nInit);
         nConstructor.setSymbol(node.getSymbol());
         nConstructor.setSourceInfo(node.getSourceInfo());
         node.setNormalizedNode(nConstructor);
       }
     }
 
     private DartExpression normalizeCompoundAssignment(Token operator,
                                                        boolean isPostfix,
                                                        DartExpression operand1,
                                                        DartExpression operand2) {
@@ skipping 249 matching lines @@
         case ASSIGN_TRUNC: return Token.TRUNC;
         case INC: return Token.ADD;
         case DEC: return Token.SUB;
 
         default:
           throw new InternalCompilerException("Invalid assignment operator");
       }
     }
   }
 }