fix #26141, add support for type arguments to constants

pkg/analyzer/lib/src/generated/resolver.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.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 1241 matching lines @@
       // evaluation.
       ConstructorElement constructor = node.staticElement;
       if (constructor != null) {
         ConstantEvaluationEngine evaluationEngine =
             new ConstantEvaluationEngine(_typeProvider, declaredVariables,
                 typeSystem: _typeSystem);
         ConstantVisitor constantVisitor =
             new ConstantVisitor(evaluationEngine, _errorReporter);
         evaluationEngine.evaluateConstructorCall(
             node,
+            (node.constructorName.type.type as ParameterizedType).typeArguments,
             node.argumentList.arguments,
             constructor,
             constantVisitor,
             _errorReporter);
       }
     }
     _validateInstanceCreationArguments(node);
     return super.visitInstanceCreationExpression(node);
   }
 
@@ skipping 5050 matching lines @@
       _currentFunctionBody = node.body;
       _enclosingFunction = node.element;
       FunctionType type = _enclosingFunction.type;
       InferenceContext.setType(node.body, type.returnType);
       super.visitConstructorDeclaration(node);
     } finally {
       _currentFunctionBody = outerFunctionBody;
       _enclosingFunction = outerFunction;
     }
     ConstructorElementImpl constructor = node.element;
-    constructor.constantInitializers =
-        new ConstantAstCloner().cloneNodeList(node.initializers);
+    var clone = new ConstantAstCloner().cloneNodeList;

[Paul Berry, 2016/07/21 20:42:14]

This hunk shouldn't be necessary.

[Jennifer Messerly, 2016/07/28 22:28:05]

Yay! Reverted!

+    if (strongMode) {
+      // Note: the order of cloning matters; it won't ever go back before the
+      // first token that is cloned. So we have to start with fields, then
+      // parameters, then constructor initializers.

[Brian Wilkerson, 2016/07/21 18:01:49]

Do you mean that nodes must be cloned in lexical order? If that's true, then
this won't work because you can't assume the order in which these declarations
appear in the source code (fields don't have to appear before constructors).

[Jennifer Messerly, 2016/07/21 18:03:11]

yes
eeeeeep. Yes, good point. Arg. I'll just switch it to make new ConstantAstCloner
objects (that's what got me in trouble)

+      var enclosingClass = node.parent as ClassDeclaration;
+      constructor.fieldInitializers = clone(enclosingClass.members
+          .where((m) => m is FieldDeclaration)
+          .expand((f) => f.fields.variables)
+          .toList());
+      constructor.parameterInitializers = clone(node.parameters.parameters
+          .where((p) => p is DefaultFormalParameter)
+          .toList());
+    }
+
+    constructor.constantInitializers = clone(node.initializers);
     return null;
   }
 
   @override
   void visitConstructorDeclarationInScope(ConstructorDeclaration node) {
     super.visitConstructorDeclarationInScope(node);
     safelyVisitComment(node.documentationComment);
   }
 
   @override
@@ skipping 4730 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }