fix #26141, add support for type arguments to constants

pkg/analyzer/lib/src/dart/element/element.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.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1969 matching lines @@
    */
   ConstructorElement _redirectedConstructor;
 
   /**
    * The initializers for this constructor (used for evaluating constant
    * instance creation expressions).
    */
   List<ConstructorInitializer> _constantInitializers;
 
   /**
+   * The initializers for fields (used for evaluating constant
+   * instance creation expressions).
+   */
+  List<VariableDeclaration> _fieldInitializers;

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

This shouldn't be necessary.  We already store the initializer ASTs for fields
in ConstFieldElementImpl (in the ConstVariableElement mixin).  Note that
ConstFieldElementImpl is a bit of a misnomer--it is actually used both for const
fields and for nonstatic final fields, precisely so that the constant evaluation
engine can evaluate field initializers of classes that have const constructors.

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

Nice!!!! Reverted this file :)

+
+  /**
+   * The initializers for default parameters (used for evaluating constant
+   * instance creation expressions).
+   */
+  List<DefaultFormalParameter> _parameterInitializers;

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

This shouldn't be necessary either.  We already store the default parameter ASTs
for constant constructors in DefaultParameterElementImpl (again, in the
ConstVariableElement mixin).

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

Reverted :)

+
+  /**
    * The offset of the `.` before this constructor name or `null` if not named.
    */
   int _periodOffset;
 
   /**
    * Return the offset of the character immediately following the last character
    * of this constructor's name, or `null` if not named.
    */
   int _nameEnd;
 
@@ skipping 37 matching lines @@
     }
     return _constantInitializers;
   }
 
   void set constantInitializers(
       List<ConstructorInitializer> constantInitializers) {
     assert(serializedExecutable == null);
     _constantInitializers = constantInitializers;
   }
 
+  List<VariableDeclaration> get fieldInitializers {

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

This hunk should be unnecessary too.

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

yup!

+    if (serializedExecutable != null && _fieldInitializers == null) {
+      _fieldInitializers ??= serializedExecutable.fieldInitializers
+          .map((i) => _buildConstructorInitializer(i))
+          .toList(growable: false);
+    }
+    return _fieldInitializers;
+  }
+
+  void set fieldInitializers(
+      List<VariableDeclaration> fieldInitializers) {
+    assert(serializedExecutable == null);
+    _fieldInitializers = fieldInitializers;
+  }
+
+  List<DefaultFormalParameter> get parameterInitializers {
+    if (serializedExecutable != null && _parameterInitializers == null) {
+      _parameterInitializers ??= serializedExecutable.parameterInitializers
+          .map((i) => _buildConstructorInitializer(i))
+          .toList(growable: false);
+    }
+    return _parameterInitializers;
+  }
+
+  void set parameterInitializers(
+      List<DefaultFormalParameter> parameterInitializers) {
+    assert(serializedExecutable == null);
+    _parameterInitializers = parameterInitializers;
+  }
+
   @override
   ClassElementImpl get enclosingElement =>
       super.enclosingElement as ClassElementImpl;
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext =>
       super.enclosingElement as ClassElementImpl;
 
   /**
    * Set whether this constructor represents a factory method.
@@ skipping 6428 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }