Remove factory body in *.fromEnvironment, and implement this same behavior

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

 // Copyright (c) 2016, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 1319 matching lines @@
     HInstruction errorMessage = graph.addConstantString(message, closedWorld);
     // TODO(sra): Associate source info from [node].
     _pushStaticInvocation(function, [errorMessage], typeMask);
   }
 
   void generateTypeError(ir.Node node, String message) {
     generateError(node, _commonElements.throwTypeError, message,
         astAdapter.getReturnTypeOf(_commonElements.throwTypeError));
   }
 
+  void generateUnsupportedError(ir.Node node, String message) {
+    generateError(node, _commonElements.throwUnsupportedError, message,
+        astAdapter.getReturnTypeOf(_commonElements.throwUnsupportedError));
+  }
+
   @override
   void visitAssertStatement(ir.AssertStatement assertStatement) {
     if (!options.enableUserAssertions) return;
     if (assertStatement.message == null) {
       assertStatement.condition.accept(this);
       _pushStaticInvocation(_commonElements.assertHelper, <HInstruction>[pop()],
           astAdapter.getReturnTypeOf(_commonElements.assertHelper));
       pop();
       return;
     }
@@ skipping 893 matching lines @@
       return;
     }
     FunctionEntity function = _elementMap.getMember(target);
     TypeMask typeMask = astAdapter.getReturnTypeOf(function);
 
     // TODO(sra): For JS interop external functions, use a different function to
     // build arguments.
     List<HInstruction> arguments =
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
 
-    // Factory constructors take type parameters; other static methods ignore
-    // them.
     if (function is ConstructorEntity && function.isFactoryConstructor) {
+      if (function.isExternal && function.isFromEnvironmentConstructor) {
+        if (invocation.isConst) {
+          // Just like all const constructors (see visitConstructorInvocation).
+          stack.add(graph.addConstant(
+              astAdapter.getConstantFor(invocation), closedWorld));
+        } else {
+          generateUnsupportedError(
+              invocation,
+              '${function.enclosingClass.name}.${function.name} '
+              'can only be used as a const constructor');
+        }
+        return;
+      }
+
+      // Factory constructors take type parameters; other static methods ignore
+      // them.
       if (backend.rtiNeed.classNeedsRti(function.enclosingClass)) {
         _addTypeArguments(arguments, invocation.arguments);
       }
     }
 
     _pushStaticInvocation(function, arguments, typeMask);
   }
 
   void handleInvokeStaticForeign(
       ir.StaticInvocation invocation, ir.Procedure target) {
@@ skipping 1115 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }