Add @anonymous annotation and restrict object literal constructors to only anonymous classes. This …

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   final SsaCodeGeneratorTask generator;
   final SsaBuilderTask builder;
   final SsaOptimizerTask optimizer;
@@ skipping 5825 matching lines @@
       push(
           new HInvokeDynamicSetter(selector, mask, null, inputs, type)
               ..sourceInformation = sourceInformation);
     } else {
       push(
           new HInvokeDynamicMethod(selector, mask, inputs, type, isIntercepted)
               ..sourceInformation = sourceInformation);
     }
   }
 
+  bool _hasNamedParameters(FunctionElement function) {
+    FunctionSignature params = function.functionSignature;
+    return params.optionalParameterCount > 0
+        && params.optionalParametersAreNamed;
+  }
+
   HForeignCode invokeJsInteropFunction(Element element,
                                        List<HInstruction> arguments,
                                        SourceInformation sourceInformation) {
     assert(backend.isJsInterop(element));
     nativeEmitter.nativeMethods.add(element);
     String templateString;
 
-    if (element.isFactoryConstructor) {
-      // Treat factory constructors as syntactic sugar for creating object
-      // literals.
+    if (element.isFactoryConstructor &&
+        backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass)) {
+      // Factory constructor that is syntactic sugar for creating a JavaScript
+      // object literal.
       ConstructorElement constructor = element;
       FunctionSignature params = constructor.functionSignature;
       int i = 0;
       int positions = 0;
       var filteredArguments = <HInstruction>[];
       var parameterNameMap = new Map<String, js.Expression>();
       params.orderedForEachParameter((ParameterElement parameter) {
         // TODO(jacobr): throw if parameter names do not match names of property
         // names in the class.
         assert (parameter.isNamed);
-        if (!parameter.isNamed) {
-          reporter.reportErrorMessage(
-              parameter, MessageKind.GENERIC,
-              {'text': 'All arguments to external constructors of JavaScript '
-                       'interop classes must be named as these constructors '
-                       'are syntactic sugar for object literals.'});
-        }
         HInstruction argument = arguments[i];
         if (argument != null) {
           filteredArguments.add(argument);
           parameterNameMap[parameter.name] =
               new js.InterpolatedExpression(positions++);
         }
         i++;
       });
       var codeTemplate = new js.Template(null,
           js.objectLiteral(parameterNameMap));
@@ skipping 18 matching lines @@
     // the factory constructor case.
     arguments = arguments.where((arg) => arg != null).toList();
     var inputs = <HInstruction>[target]..addAll(arguments);
 
     js.Template codeTemplate;
     if (element.isGetter) {
       codeTemplate = js.js.parseForeignJS("#");
     } else if (element.isSetter) {
       codeTemplate = js.js.parseForeignJS("# = #");
     } else {
+      FunctionElement function = element;
+      FunctionSignature params = function.functionSignature;
+
       var argsStub = <String>[];
       for (int i = 0; i < arguments.length; i++) {
         argsStub.add('#');
       }
+
       if (element.isConstructor) {
         codeTemplate = js.js.parseForeignJS("new #(${argsStub.join(",")})");
       } else {
         codeTemplate = js.js.parseForeignJS("#(${argsStub.join(",")})");
       }
     }
 
     var nativeBehavior = new native.NativeBehavior()
       ..codeTemplate = codeTemplate
       ..typesReturned.add(
@@ skipping 3217 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.helpers.DynamicRuntimeType;
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }