fix #26141, add support for type arguments to constants

pkg/analyzer/lib/src/dart/constant/evaluation.dart

 // Copyright (c) 2014, 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.
 
 library analyzer.src.dart.constant.evaluation;
 
 import 'dart:collection';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 57 matching lines @@
    * The set of variables declared on the command line using '-D'.
    */
   final DeclaredVariables _declaredVariables;
 
   /**
    * Validator used to verify correct dependency analysis when running unit
    * tests.
    */
   final ConstantEvaluationValidator validator;
 
+  /** Whether we are running in strong mode. */
+  final bool strongMode;
+
   /**
    * Initialize a newly created [ConstantEvaluationEngine].  The [typeProvider]
    * is used to access known types.  [_declaredVariables] is the set of
    * variables declared on the command line using '-D'.  The [validator], if
    * given, is used to verify correct dependency analysis when running unit
    * tests.
    */
-  ConstantEvaluationEngine(this.typeProvider, this._declaredVariables,
+  ConstantEvaluationEngine(TypeProvider typeProvider, this._declaredVariables,
       {ConstantEvaluationValidator validator, TypeSystem typeSystem})
-      : validator =
+      : typeProvider = typeProvider,
+        strongMode =
+            typeProvider.objectType.element.context.analysisOptions.strongMode,
+        validator =
             validator ?? new ConstantEvaluationValidator_ForProduction(),
         typeSystem = typeSystem ?? new TypeSystemImpl();
 
   /**
    * Check that the arguments to a call to fromEnvironment() are correct. The
    * [arguments] are the AST nodes of the arguments. The [argumentValues] are
    * the values of the unnamed arguments. The [namedArgumentValues] are the
    * values of the named arguments. The [expectedDefaultValueType] is the
    * allowed type of the "defaultValue" parameter (if present). Note:
    * "defaultValue" is always allowed to be null. Return `true` if the arguments
@@ skipping 126 matching lines @@
       } else if (element is ConstructorElementImpl &&
           element.isConst &&
           constNode.arguments != null) {
         RecordingErrorListener errorListener = new RecordingErrorListener();
         ErrorReporter errorReporter =
             new ErrorReporter(errorListener, constant.source);
         ConstantVisitor constantVisitor =
             new ConstantVisitor(this, errorReporter);
         DartObjectImpl result = evaluateConstructorCall(
             constNode,
+            [],
             constNode.arguments.arguments,
             element,
             constantVisitor,
             errorReporter);
         constant.evaluationResult =
             new EvaluationResultImpl(result, errorListener.errors);
       } else {
         // This may happen for invalid code (e.g. failing to pass arguments
         // to an annotation which references a const constructor).  The error
         // is detected elsewhere, so just silently ignore it here.
@@ skipping 158 matching lines @@
         // The VM would use the built-in default value, but we don't want to do
         // that for analysis because it's likely to lead to cascading errors.
         // So just leave [value] in the unknown state.
       }
     }
     return value;
   }
 
   DartObjectImpl evaluateConstructorCall(
       AstNode node,
-      NodeList<Expression> arguments,
+      List<DartType> typeArguments,
+      List<Expression> arguments,
       ConstructorElement constructor,
       ConstantVisitor constantVisitor,
       ErrorReporter errorReporter) {
     if (!getConstructorImpl(constructor).isCycleFree) {
       // It's not safe to evaluate this constructor, so bail out.
       // TODO(paulberry): ensure that a reasonable error message is produced
       // in this case, as well as other cases involving constant expression
       // circularities (e.g. "compile-time constant expression depends on
       // itself")
       return new DartObjectImpl.validWithUnknownValue(constructor.returnType);
@@ skipping 85 matching lines @@
     List<ConstructorInitializer> initializers =
         constructorBase.constantInitializers;
     if (initializers == null) {
       // This can happen in some cases where there are compile errors in the
       // code being analyzed (for example if the code is trying to create a
       // const instance using a non-const constructor, or the node we're
       // visiting is involved in a cycle).  The error has already been reported,
       // so consider it an unknown value to suppress further errors.
       return new DartObjectImpl.validWithUnknownValue(definingClass);
     }
-    HashMap<String, DartObjectImpl> fieldMap =
-        new HashMap<String, DartObjectImpl>();
+    var fieldMap = new HashMap<String, DartObjectImpl>();
+    var typeArgumentMap = new HashMap<String, DartObjectImpl>.fromIterables(
+        (constructor.returnType as ParameterizedType)
+            .typeParameters
+            .map((t) => t.name),
+        typeArguments.map((t) =>
+            new DartObjectImpl(typeProvider.typeType, new TypeState(t))));
+
+    var fieldInitVisitor = new ConstantVisitor(this, errorReporter,
+        lexicalEnvironment: typeArgumentMap);
     // Start with final fields that are initialized at their declaration site.
-    for (FieldElement field in constructor.enclosingElement.fields) {
+    List<FieldElement> fields = constructor.enclosingElement.fields;
+    for (int i = 0; i < fields.length; i++) {
+      FieldElement field = fields[i];
       if ((field.isFinal || field.isConst) &&
           !field.isStatic &&
           field is ConstFieldElementImpl) {
         validator.beforeGetFieldEvaluationResult(field);
-        EvaluationResultImpl evaluationResult = field.evaluationResult;
+
+        DartObjectImpl fieldValue;
+        if (strongMode) {
+          var fieldInit = constructorBase.fieldInitializers[i].initializer;
+          fieldValue = fieldInit.accept(fieldInitVisitor);
+        } else {
+          fieldValue = field.evaluationResult?.value;
+        }
         // It is possible that the evaluation result is null.
         // This happens for example when we have duplicate fields.
         // class Test {final x = 1; final x = 2; const Test();}
-        if (evaluationResult == null) {
+        if (fieldValue == null) {
           continue;
         }
         // Match the value and the type.
         DartType fieldType =
             FieldMember.from(field, constructor.returnType).type;
-        DartObjectImpl fieldValue = evaluationResult.value;
         if (fieldValue != null && !runtimeTypeMatch(fieldValue, fieldType)) {
           errorReporter.reportErrorForNode(
               CheckedModeCompileTimeErrorCode
                   .CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
               node,
               [fieldValue.type, field.name, fieldType]);
         }
         fieldMap[field.name] = fieldValue;
       }
     }
     // Now evaluate the constructor declaration.
     HashMap<String, DartObjectImpl> parameterMap =
         new HashMap<String, DartObjectImpl>();
     List<ParameterElement> parameters = constructor.parameters;
     int parameterCount = parameters.length;
+
+    HashMap<ParameterElement, DefaultFormalParameter> parameterDefaultMap;
+    if (strongMode) {
+      parameterDefaultMap = new HashMap.fromIterable(
+          constructorBase.parameterInitializers,
+          key: (p) => p.parameter.element);
+    }
+
     for (int i = 0; i < parameterCount; i++) {
       ParameterElement parameter = parameters[i];
       ParameterElement baseParameter = parameter;
       while (baseParameter is ParameterMember) {
         baseParameter = (baseParameter as ParameterMember).baseElement;
       }
       DartObjectImpl argumentValue = null;
       AstNode errorTarget = null;
       if (baseParameter.parameterKind == ParameterKind.NAMED) {
         argumentValue = namedArgumentValues[baseParameter.name];
         errorTarget = namedArgumentNodes[baseParameter.name];
       } else if (i < argumentCount) {
         argumentValue = argumentValues[i];
         errorTarget = argumentNodes[i];
       }
       if (errorTarget == null) {
         // No argument node that we can direct error messages to, because we
         // are handling an optional parameter that wasn't specified.  So just
         // direct error messages to the constructor call.
         errorTarget = node;
       }
       if (argumentValue == null && baseParameter is ParameterElementImpl) {
         // The parameter is an optional positional parameter for which no value
         // was provided, so use the default value.
         validator.beforeGetParameterDefault(baseParameter);
-        EvaluationResultImpl evaluationResult = baseParameter.evaluationResult;
-        if (evaluationResult == null) {
-          // No default was provided, so the default value is null.
-          argumentValue = typeProvider.nullObject;
-        } else if (evaluationResult.value != null) {
-          argumentValue = evaluationResult.value;
+        if (strongMode) {
+          var defaultValue = parameterDefaultMap[parameter]?.defaultValue;
+          if (defaultValue == null) {
+            argumentValue = typeProvider.nullObject;
+          } else {
+            argumentValue = defaultValue.accept(fieldInitVisitor);
+          }
+        } else {
+          EvaluationResultImpl evaluationResult =
+              baseParameter.evaluationResult;
+          if (evaluationResult == null) {
+            // No default was provided, so the default value is null.
+            argumentValue = typeProvider.nullObject;
+          } else if (evaluationResult.value != null) {
+            argumentValue = evaluationResult.value;
+          }
         }
       }
       if (argumentValue != null) {
         if (!runtimeTypeMatch(argumentValue, parameter.type)) {
           errorReporter.reportErrorForNode(
               CheckedModeCompileTimeErrorCode
                   .CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
               errorTarget,
               [argumentValue.type, parameter.type]);
         }
@@ skipping 61 matching lines @@
           superName = name.name;
         }
         superArguments = initializer.argumentList.arguments;
       } else if (initializer is RedirectingConstructorInvocation) {
         // This is a redirecting constructor, so just evaluate the constructor
         // it redirects to.
         ConstructorElement constructor = initializer.staticElement;
         if (constructor != null && constructor.isConst) {
           return evaluateConstructorCall(
               node,
+              typeArguments,
               initializer.argumentList.arguments,
               constructor,
               initializerVisitor,
               errorReporter);
         }
       }
     }
     // Evaluate explicit or implicit call to super().
     InterfaceType superclass = definingClass.superclass;
     if (superclass != null && !superclass.isObject) {
       ConstructorElement superConstructor =
           superclass.lookUpConstructor(superName, constructor.library);
       if (superConstructor != null) {
         if (superArguments == null) {
           superArguments = new NodeList<Expression>(null);
         }
-        evaluateSuperConstructorCall(node, fieldMap, superConstructor,
-            superArguments, initializerVisitor, errorReporter);
+
+        evaluateSuperConstructorCall(
+            node,
+            fieldMap,
+            superConstructor,
+            superclass.typeArguments,
+            superArguments,
+            initializerVisitor,
+            errorReporter);
       }
     }
     return new DartObjectImpl(definingClass, new GenericState(fieldMap));
   }
 
   void evaluateSuperConstructorCall(
       AstNode node,
       HashMap<String, DartObjectImpl> fieldMap,
       ConstructorElement superConstructor,
-      NodeList<Expression> superArguments,
+      List<DartType> superTypeArguments,
+      List<Expression> superArguments,
       ConstantVisitor initializerVisitor,
       ErrorReporter errorReporter) {
     if (superConstructor != null && superConstructor.isConst) {
-      DartObjectImpl evaluationResult = evaluateConstructorCall(node,
-          superArguments, superConstructor, initializerVisitor, errorReporter);
+      DartObjectImpl evaluationResult = evaluateConstructorCall(
+          node,
+          superTypeArguments,
+          superArguments,
+          superConstructor,
+          initializerVisitor,
+          errorReporter);
       if (evaluationResult != null) {
         fieldMap[GenericState.SUPERCLASS_FIELD] = evaluationResult;
       }
     }
   }
 
   /**
    * Attempt to follow the chain of factory redirections until a constructor is
    * reached which is not a const factory constructor. Return the constant
    * constructor which terminates the chain of factory redirections, if the
@@ skipping 517 matching lines @@
       // TODO(brianwilkerson) Figure out which error to report.
       _error(node, null);
       return null;
     }
     ConstructorElement constructor = node.staticElement;
     if (constructor == null) {
       // Couldn't resolve the constructor so we can't compute a value.  No
       // problem - the error has already been reported.
       return null;
     }
-    return evaluationEngine.evaluateConstructorCall(
-        node, node.argumentList.arguments, constructor, this, _errorReporter);
+
+    var type = constructor.returnType as ParameterizedType;
+    var typeArguments = type.typeArguments.map((t) {
+      if (t is TypeParameterType && _lexicalEnvironment != null) {
+        return _lexicalEnvironment[t.name]?.toTypeValue() ?? t;
+      }
+      return t;
+    }).toList();
+
+    if (constructor is ConstructorMember) {
+      constructor = (constructor as ConstructorMember).baseElement;
+    }
+
+    constructor = ConstructorMember.from(
+        constructor,
+        type.substitute2(typeArguments, type.typeArguments));
+
+    return evaluationEngine.evaluateConstructorCall(node, typeArguments,
+        node.argumentList.arguments, constructor, this, _errorReporter);
   }
 
   @override
   DartObjectImpl visitIntegerLiteral(IntegerLiteral node) =>
       new DartObjectImpl(_typeProvider.intType, new IntState(node.value));
 
   @override
   DartObjectImpl visitInterpolationExpression(InterpolationExpression node) {
     DartObjectImpl result = node.expression.accept(this);
     if (result != null && !result.isBoolNumStringOrNull) {
@@ skipping 212 matching lines @@
     for (int i = 0; i < components.length; i++) {
       if (i > 0) {
         buffer.writeCharCode(0x2E);
       }
       buffer.write(components[i].lexeme);
     }
     return new DartObjectImpl(
         _typeProvider.symbolType, new SymbolState(buffer.toString()));
   }
 
+  @override
+  DartObjectImpl visitTypeName(TypeName node) {
+    // TODO(jmesserly): what to do about type arguments?
+    String name = node.name.name;
+    if (_lexicalEnvironment != null && _lexicalEnvironment.containsKey(name)) {
+      return _lexicalEnvironment[name];
+    }
+    return new DartObjectImpl(_typeProvider.typeType, new TypeState(node.type));
+  }
+
   /**
    * Create an error associated with the given [node]. The error will have the
    * given error [code].
    */
   void _error(AstNode node, ErrorCode code) {
     _errorReporter.reportErrorForNode(
         code ?? CompileTimeErrorCode.INVALID_CONSTANT, node);
   }
 
   /**
@@ skipping 12 matching lines @@
       }
     } else if (variableElement is ExecutableElement) {
       ExecutableElement function = element;
       if (function.isStatic) {
         ParameterizedType functionType = function.type;
         if (functionType == null) {
           functionType = _typeProvider.functionType;
         }
         return new DartObjectImpl(functionType, new FunctionState(function));
       }
-    } else if (variableElement is ClassElement ||
-        variableElement is FunctionTypeAliasElement ||
-        variableElement is DynamicElementImpl) {
-      return new DartObjectImpl(_typeProvider.typeType, new TypeState(element));
+    } else if (variableElement is TypeDefiningElement) {
+      return new DartObjectImpl(
+          _typeProvider.typeType, new TypeState(variableElement.type));
     }
     // TODO(brianwilkerson) Figure out which error to report.
     _error(node, null);
     return null;
   }
 
   /**
    * Return `true` if the given [targetResult] represents a string and the
    * [identifier] is "length".
    */
@@ skipping 470 matching lines @@
   }
 
   @override
   String toString() {
     if (value == null) {
       return "error";
     }
     return value.toString();
   }
 }