anchor.diff:          constructor.function.body is! EmptyStatement) {
         throw 'Constructor "$node" has non-trivial body "${constructor.function.body.runtimeType}".';
       }
  -    if (constructor.isInExternalLibrary &&
  -        constructor.initializers.isEmpty &&
  -        constructor.enclosingClass.supertype != null) {
  -      // The constructor is unavailable due to separate compilation.
  -      return new UnevaluatedConstant(new ConstructorInvocation(
  -          constructor, unevaluatedArguments(node.arguments),
  -          isConst: true));
  -    }
       if (klass.isAbstract) {
         throw 'Constructor "$node" belongs to abstract class "${klass}".';
       }
   
  -    final typeArguments = evaluateTypeArguments(node, node.arguments);
       final positionals = evaluatePositionalArguments(node.arguments);
       final named = evaluateNamedArguments(node.arguments);
  +
  +    bool isUnavailable = constructor.isInExternalLibrary &&
  +        constructor.initializers.isEmpty &&
  +        constructor.enclosingClass.supertype != null;
  +    if (isUnavailable) {
  +      // The constructor is unavailable due to separate compilation.
  +      return unevaluated(new ConstructorInvocation(constructor,
  +          unevaluatedArguments(positionals, named, node.arguments.types),
  +          isConst: true));
  +    }
  +
  +    final typeArguments = evaluateTypeArguments(node, node.arguments);
   
       // Fill in any missing type arguments with "dynamic".
       for (int i = typeArguments.length; i < klass.typeParameters.length; i++) {
  
positive.code:   visitStaticInvocation(StaticInvocation node) {
      final Procedure target = node.target;
      final Arguments arguments = node.arguments;
      if (target.kind == ProcedureKind.Factory) {
        if (target.isConst &&
            target.name.name == "fromEnvironment" &&
            target.enclosingLibrary == coreTypes.coreLibrary &&
            arguments.positional.length == 1) {
          if (environmentDefines != null) {
            // Evaluate environment constant.
            Constant name = arguments.positional[0].accept(this);
            if (name is StringConstant) {
              String value = environmentDefines[name.value];
              Constant defaultValue = null;
              for (int i = 0; i < arguments.named.length; i++) {
                NamedExpression named = arguments.named[i];
                if (named.name == "defaultValue") {
                  defaultValue = named.value.accept(this);
                  break;
                }
              }
  
              if (target.enclosingClass == coreTypes.boolClass) {
                Constant boolConstant = value == "true"
  
negative.code:         if (target.isConst) {
            if (target.isInExternalLibrary && target.initializer == null) {
              // The variable is unavailable due to separate compilation.
              return unevaluated(node);
            }
            return runInsideContext(target, () {
              return _evaluateSubexpression(target.initializer);
  