Handle .fromEnvironment and incompatible constructor invocations

pkg/compiler/lib/src/resolution/send_resolver.dart

 // Copyright (c) 2015, 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 dart2js.semantics_visitor;
 
 enum SendStructureKind {
   GET,
   SET,
   INVOKE,
@@ skipping 523 matching lines @@
         return new StaticAccess.unresolved(null);
       } else {
         return handleStaticallyResolvedAccess(
             node, element, getter, isCompound: isCompound);
       }
     }
   }
 
   ConstructorAccessSemantics computeConstructorAccessSemantics(
         ConstructorElement constructor,
+        CallStructure callStructure,
         DartType type,
         {bool mustBeConstant: false}) {
     if (mustBeConstant && !constructor.isConst) {
       return new ConstructorAccessSemantics(
           ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR, constructor, type);
     }
     if (constructor.isErroneous) {
       if (constructor is ErroneousElement) {
         ErroneousElement error = constructor;
         if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
           return new ConstructorAccessSemantics(
               ConstructorAccessKind.UNRESOLVED_CONSTRUCTOR, constructor, type);
         }
       }
       return new ConstructorAccessSemantics(
           ConstructorAccessKind.UNRESOLVED_TYPE, constructor, type);
-    } else if (constructor.isRedirectingFactory) {
-      ConstructorElement effectiveTarget = constructor.effectiveTarget;
-      if (effectiveTarget == constructor ||
-          effectiveTarget.isErroneous ||
-          (mustBeConstant && !effectiveTarget.isConst)) {
+    } else {
+      if (!callStructure.signatureApplies(constructor)) {
         return new ConstructorAccessSemantics(
-            ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY,
+            ConstructorAccessKind.INCOMPATIBLE,
             constructor,
             type);
       }
-      ConstructorAccessSemantics effectiveTargetSemantics =
-          computeConstructorAccessSemantics(
-              effectiveTarget,
-              constructor.computeEffectiveTargetType(type));
-      if (effectiveTargetSemantics.isErroneous) {
+      if (constructor.isRedirectingFactory) {
+        ConstructorElement effectiveTarget = constructor.effectiveTarget;
+        if (effectiveTarget == constructor ||
+            effectiveTarget.isErroneous ||
+            (mustBeConstant && !effectiveTarget.isConst)) {
+          return new ConstructorAccessSemantics(
+              ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY,
+              constructor,
+              type);
+        }
+        ConstructorAccessSemantics effectiveTargetSemantics =
+            computeConstructorAccessSemantics(
+                effectiveTarget,
+                callStructure,
+                constructor.computeEffectiveTargetType(type));
+        if (effectiveTargetSemantics.isErroneous) {
+          return new RedirectingFactoryConstructorAccessSemantics(
+              ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY,
+              constructor,
+              type,
+              effectiveTargetSemantics);
+        }
         return new RedirectingFactoryConstructorAccessSemantics(
-            ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY,
+            ConstructorAccessKind.REDIRECTING_FACTORY,
             constructor,
             type,
             effectiveTargetSemantics);
+      } else if (constructor.isFactoryConstructor) {
+        return new ConstructorAccessSemantics(
+            ConstructorAccessKind.FACTORY, constructor, type);
+      } else if (constructor.isRedirectingGenerative) {
+        if (constructor.enclosingClass.isAbstract) {
+            return new ConstructorAccessSemantics(
+                ConstructorAccessKind.ABSTRACT, constructor, type);
+        }
+        return new ConstructorAccessSemantics(
+            ConstructorAccessKind.REDIRECTING_GENERATIVE, constructor, type);
+      } else if (constructor.enclosingClass.isAbstract) {
+        return new ConstructorAccessSemantics(
+            ConstructorAccessKind.ABSTRACT, constructor, type);
+      } else {
+        return new ConstructorAccessSemantics(
+            ConstructorAccessKind.GENERATIVE, constructor, type);
       }
-      return new RedirectingFactoryConstructorAccessSemantics(
-          ConstructorAccessKind.REDIRECTING_FACTORY,
-          constructor,
-          type,
-          effectiveTargetSemantics);
-    } else if (constructor.isFactoryConstructor) {
-      return new ConstructorAccessSemantics(
-          ConstructorAccessKind.FACTORY, constructor, type);
-    } else if (constructor.isRedirectingGenerative) {
-      if (constructor.enclosingClass.isAbstract) {
-          return new ConstructorAccessSemantics(
-              ConstructorAccessKind.ABSTRACT, constructor, type);
-      }
-      return new ConstructorAccessSemantics(
-          ConstructorAccessKind.REDIRECTING_GENERATIVE, constructor, type);
-    } else if (constructor.enclosingClass.isAbstract) {
-      return new ConstructorAccessSemantics(
-          ConstructorAccessKind.ABSTRACT, constructor, type);
-    } else {
-      return new ConstructorAccessSemantics(
-          ConstructorAccessKind.GENERATIVE, constructor, type);
     }
   }
 
   NewStructure computeNewStructure(NewExpression node) {
     Element element = elements[node.send];
     Selector selector = elements.getSelector(node.send);
     DartType type = elements.getType(node);
 
     ConstructorAccessSemantics constructorAccessSemantics =
         computeConstructorAccessSemantics(
-            element, type, mustBeConstant: node.isConst);
+            element, selector.callStructure, type,
+            mustBeConstant: node.isConst);
     if (node.isConst) {
       ConstantExpression constant = elements.getConstant(node);
       if (constructorAccessSemantics.isErroneous ||
-          constant is! ConstructedConstantExpression) {
+          constant == null ||
+          constant.kind == ConstantExpressionKind.ERRONEOUS) {
         // This is a non-constant constant constructor invocation, like
         // `const Const(method())`.
         constructorAccessSemantics = new ConstructorAccessSemantics(
             ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR, element, type);
       } else {
-        return new ConstInvokeStructure(constant);
+        ConstantInvokeKind kind;
+        switch (constant.kind) {
+          case ConstantExpressionKind.CONSTRUCTED:
+            kind = ConstantInvokeKind.CONSTRUCTED;
+            break;
+          case ConstantExpressionKind.BOOL_FROM_ENVIRONMENT:
+            kind = ConstantInvokeKind.BOOL_FROM_ENVIRONMENT;
+            break;
+          case ConstantExpressionKind.INT_FROM_ENVIRONMENT:
+            kind = ConstantInvokeKind.INT_FROM_ENVIRONMENT;
+            break;
+          case ConstantExpressionKind.STRING_FROM_ENVIRONMENT:
+            kind = ConstantInvokeKind.STRING_FROM_ENVIRONMENT;
+            break;
+          default:
+            return internalError(
+                node, "Unexpected constant kind $kind: ${constant.getText()}");
+        }
+        return new ConstInvokeStructure(kind, constant);
       }
     }
     return new NewInvokeStructure(constructorAccessSemantics, selector);
   }
 }
 
 abstract class DeclStructure<R, A> {
   final FunctionElement element;
 
   DeclStructure(this.element);
@@ skipping 321 matching lines @@
       return internalError(node, "Unexpected variable $element.");
     }
     if (element.isConst) {
       ConstantExpression constant = elements.getConstant(element.initializer);
       return new ConstantVariableStructure(kind, node, element, constant);
     } else {
       return new NonConstantVariableStructure(kind, node, element);
     }
   }
 }