Resynthesize constructor initializers.

pkg/analyzer/test/src/summary/resynthesize_test.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.
 
 library test.src.serialization.elements_test;
 
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 224 matching lines @@
         comparePropertyAccessorElements(
             resynthesized.accessors[i],
             original.accessors
                 .singleWhere((PropertyAccessorElement e) => e.name == name),
             'setter $name');
       }
     }
     // TODO(paulberry): test metadata and offsetToElementMap.
   }
 
-  void compareConstantAsts(AstNode r, AstNode o, String desc) {
-    void compareLists(List<Object> rItems, List<Object> oItems) {
-      if (rItems == null && oItems == null) {
-        return;
-      }
-      expect(rItems != null && oItems != null, isTrue);
-      expect(rItems, hasLength(oItems.length));
-      for (int i = 0; i < oItems.length; i++) {
-        Object rItem = rItems[i];
-        Object oItem = oItems[i];
-        if (rItem is Expression && oItem is Expression) {
-          compareConstantAsts(rItem, oItem, desc);
-        } else if (rItem is TypeName && oItem is TypeName) {
-          compareConstantAsts(rItem.name, oItem.name, desc);
-        } else if (rItem is InterpolationString &&
-            oItem is InterpolationString) {
-          expect(rItem.value, oItem.value);
-        } else if (rItem is InterpolationExpression &&
-            oItem is InterpolationExpression) {
-          compareConstantAsts(rItem.expression, oItem.expression, desc);
-        } else if (rItem is MapLiteralEntry && oItem is MapLiteralEntry) {
-          compareConstantAsts(rItem.key, oItem.key, desc);
-          compareConstantAsts(rItem.value, oItem.value, desc);
+  void compareConstAstLists(
+      List<Object> rItems, List<Object> oItems, String desc) {
+    if (rItems == null && oItems == null) {
+      return;
+    }
+    expect(rItems != null && oItems != null, isTrue);
+    expect(rItems, hasLength(oItems.length));
+    for (int i = 0; i < oItems.length; i++) {
+      Object rItem = rItems[i];
+      Object oItem = oItems[i];
+      if (rItem is Expression && oItem is Expression) {
+        compareConstAsts(rItem, oItem, desc);
+      } else if (rItem is TypeName && oItem is TypeName) {
+        compareConstAsts(rItem.name, oItem.name, desc);
+      } else if (rItem is InterpolationString && oItem is InterpolationString) {
+        expect(rItem.value, oItem.value);
+      } else if (rItem is InterpolationExpression &&
+          oItem is InterpolationExpression) {
+        compareConstAsts(rItem.expression, oItem.expression, desc);
+      } else if (rItem is MapLiteralEntry && oItem is MapLiteralEntry) {
+        compareConstAsts(rItem.key, oItem.key, desc);
+        compareConstAsts(rItem.value, oItem.value, desc);
+      } else if (oItem is ConstructorFieldInitializer &&
+          rItem is ConstructorFieldInitializer) {
+        compareConstAsts(rItem.fieldName, oItem.fieldName, desc);
+        if (constantInitializersAreInvalid) {
+          _assertUnresolvedIdentifier(rItem.expression, desc);
         } else {
-          fail('$desc Incompatible item types: '
-              '${rItem.runtimeType} vs. ${oItem.runtimeType}');
+          compareConstAsts(rItem.expression, oItem.expression, desc);
         }
+      } else if (oItem is SuperConstructorInvocation &&
+          rItem is SuperConstructorInvocation) {
+        compareElements(rItem.staticElement, oItem.staticElement, desc);
+        compareConstAsts(rItem.constructorName, oItem.constructorName, desc);
+        compareConstAstLists(
+            rItem.argumentList.arguments, oItem.argumentList.arguments, desc);
+      } else if (oItem is RedirectingConstructorInvocation &&
+          rItem is RedirectingConstructorInvocation) {
+        compareElements(rItem.staticElement, oItem.staticElement, desc);
+        compareConstAsts(rItem.constructorName, oItem.constructorName, desc);
+        compareConstAstLists(
+            rItem.argumentList.arguments, oItem.argumentList.arguments, desc);
+      } else {
+        fail('$desc Incompatible item types: '
+            '${rItem.runtimeType} vs. ${oItem.runtimeType}');
       }
     }
+  }
+
+  void compareConstAsts(AstNode r, AstNode o, String desc) {
     if (o == null) {
       expect(r, isNull, reason: desc);
     } else {
       expect(r, isNotNull, reason: desc);
       // ConstantAstCloner does not copy static types, and constant values
       // computer does not use static types. So, we don't set them during
       // resynthesis and should not check them here.
       if (o is ParenthesizedExpression) {
         // We don't resynthesize parenthesis, so just ignore it.
-        compareConstantAsts(r, o.expression, desc);
+        compareConstAsts(r, o.expression, desc);
       } else if (o is SimpleIdentifier && r is SimpleIdentifier) {
         expect(r.name, o.name, reason: desc);
         compareElements(r.staticElement, o.staticElement, desc);
       } else if (o is PrefixedIdentifier && r is SimpleIdentifier) {
         // We often don't resynthesize prefixed identifiers.
         // We use simple identifiers with correct elements.
-        compareConstantAsts(r, o.identifier, desc);
+        compareConstAsts(r, o.identifier, desc);
       } else if (o is PrefixedIdentifier && r is PrefixedIdentifier) {
-        compareConstantAsts(r.prefix, o.prefix, desc);
-        compareConstantAsts(r.identifier, o.identifier, desc);
+        compareConstAsts(r.prefix, o.prefix, desc);
+        compareConstAsts(r.identifier, o.identifier, desc);
       } else if (o is PropertyAccess && r is PropertyAccess) {
-        compareConstantAsts(r.target, o.target, desc);
+        compareConstAsts(r.target, o.target, desc);
         expect(r.propertyName.name, o.propertyName.name, reason: desc);
         compareElements(
             r.propertyName.staticElement, o.propertyName.staticElement, desc);
       } else if (o is PropertyAccess && r is SimpleIdentifier) {
         // We don't resynthesize property access.
         // We use simple identifiers with correct elements.
-        compareConstantAsts(r, o.propertyName, desc);
+        compareConstAsts(r, o.propertyName, desc);
       } else if (o is NullLiteral) {
         expect(r, new isInstanceOf<NullLiteral>(), reason: desc);
       } else if (o is BooleanLiteral && r is BooleanLiteral) {
         expect(r.value, o.value, reason: desc);
       } else if (o is IntegerLiteral && r is IntegerLiteral) {
         expect(r.value, o.value, reason: desc);
       } else if (o is DoubleLiteral && r is DoubleLiteral) {
         expect(r.value, o.value, reason: desc);
       } else if (o is StringInterpolation && r is StringInterpolation) {
-        compareLists(r.elements, o.elements);
+        compareConstAstLists(r.elements, o.elements, desc);
       } else if (o is StringLiteral && r is StringLiteral) {
         // We don't keep all the tokens of AdjacentStrings.
         // So, we can compare only their values.
         expect(r.stringValue, o.stringValue, reason: desc);
       } else if (o is SymbolLiteral && r is SymbolLiteral) {
         // We don't keep all the tokens of symbol literals.
         // So, we can compare only their values.
         expect(r.components.map((t) => t.lexeme).join('.'),
             o.components.map((t) => t.lexeme).join('.'),
             reason: desc);
       } else if (o is NamedExpression && r is NamedExpression) {
         expect(r.name.label.name, o.name.label.name, reason: desc);
-        compareConstantAsts(r.expression, o.expression, desc);
+        compareConstAsts(r.expression, o.expression, desc);
       } else if (o is BinaryExpression && r is BinaryExpression) {
         expect(r.operator.lexeme, o.operator.lexeme, reason: desc);
-        compareConstantAsts(r.leftOperand, o.leftOperand, desc);
-        compareConstantAsts(r.rightOperand, o.rightOperand, desc);
+        compareConstAsts(r.leftOperand, o.leftOperand, desc);
+        compareConstAsts(r.rightOperand, o.rightOperand, desc);
       } else if (o is PrefixExpression && r is PrefixExpression) {
         expect(r.operator.lexeme, o.operator.lexeme, reason: desc);
-        compareConstantAsts(r.operand, o.operand, desc);
+        compareConstAsts(r.operand, o.operand, desc);
       } else if (o is ConditionalExpression && r is ConditionalExpression) {
-        compareConstantAsts(r.condition, o.condition, desc);
-        compareConstantAsts(r.thenExpression, o.thenExpression, desc);
-        compareConstantAsts(r.elseExpression, o.elseExpression, desc);
+        compareConstAsts(r.condition, o.condition, desc);
+        compareConstAsts(r.thenExpression, o.thenExpression, desc);
+        compareConstAsts(r.elseExpression, o.elseExpression, desc);
       } else if (o is ListLiteral && r is ListLiteral) {
-        compareLists(r.typeArguments?.arguments, o.typeArguments?.arguments);
-        compareLists(r.elements, o.elements);
+        compareConstAstLists(
+            r.typeArguments?.arguments, o.typeArguments?.arguments, desc);
+        compareConstAstLists(r.elements, o.elements, desc);
       } else if (o is MapLiteral && r is MapLiteral) {
-        compareLists(r.typeArguments?.arguments, o.typeArguments?.arguments);
-        compareLists(r.entries, o.entries);
+        compareConstAstLists(
+            r.typeArguments?.arguments, o.typeArguments?.arguments, desc);
+        compareConstAstLists(r.entries, o.entries, desc);
       } else if (o is InstanceCreationExpression &&
           r is InstanceCreationExpression) {
         compareElements(r.staticElement, o.staticElement, desc);
         ConstructorName oConstructor = o.constructorName;
         ConstructorName rConstructor = r.constructorName;
         expect(oConstructor, isNotNull, reason: desc);
         expect(rConstructor, isNotNull, reason: desc);
         compareElements(
             rConstructor.staticElement, oConstructor.staticElement, desc);
         TypeName oType = oConstructor.type;
         TypeName rType = rConstructor.type;
         expect(oType, isNotNull, reason: desc);
         expect(rType, isNotNull, reason: desc);
-        compareConstantAsts(rType.name, oType.name, desc);
-        compareConstantAsts(rConstructor.name, oConstructor.name, desc);
-        compareLists(
-            rType.typeArguments?.arguments, oType.typeArguments?.arguments);
-        compareLists(r.argumentList.arguments, o.argumentList.arguments);
+        compareConstAsts(rType.name, oType.name, desc);
+        compareConstAsts(rConstructor.name, oConstructor.name, desc);
+        compareConstAstLists(rType.typeArguments?.arguments,
+            oType.typeArguments?.arguments, desc);
+        compareConstAstLists(
+            r.argumentList.arguments, o.argumentList.arguments, desc);
       } else if (o is AnnotationImpl && r is AnnotationImpl) {
         expect(o.atSign.lexeme, r.atSign.lexeme, reason: desc);
         Identifier rName = r.name;
         Identifier oName = o.name;
         if (oName is PrefixedIdentifier && o.constructorName != null) {
           // E.g. `@prefix.cls.ctor`.  This gets resynthesized as `@cls.ctor`,
           // with `cls.ctor` represented as a PrefixedIdentifier.
           expect(rName, new isInstanceOf<PrefixedIdentifier>(), reason: desc);
           if (rName is PrefixedIdentifier) {
-            compareConstantAsts(rName.prefix, oName.identifier, desc);
+            compareConstAsts(rName.prefix, oName.identifier, desc);
             expect(rName.period.lexeme, '.', reason: desc);
-            compareConstantAsts(rName.identifier, o.constructorName, desc);
+            compareConstAsts(rName.identifier, o.constructorName, desc);
             expect(r.period, isNull, reason: desc);
             expect(r.constructorName, isNull, reason: desc);
           }
         } else {
-          compareConstantAsts(r.name, o.name, desc);
+          compareConstAsts(r.name, o.name, desc);
           expect(r.period?.lexeme, o.period?.lexeme, reason: desc);
-          compareConstantAsts(r.constructorName, o.constructorName, desc);
+          compareConstAsts(r.constructorName, o.constructorName, desc);
         }
-        compareLists(r.arguments?.arguments, o.arguments?.arguments);
+        compareConstAstLists(
+            r.arguments?.arguments, o.arguments?.arguments, desc);
         Element expectedElement = o.element;
         if (oName is PrefixedIdentifier && o.constructorName != null) {
           // Due to dartbug.com/25706, [o.element] incorrectly points to the
           // class rather than the named constructor.  Hack around this.
           // TODO(paulberry): when dartbug.com/25706 is fixed, remove this.
           expectedElement = (expectedElement as ClassElement)
               .getNamedConstructor(o.constructorName.name);
           expect(expectedElement, isNotNull, reason: desc);
         }
         compareElements(r.element, expectedElement, desc);
         // elementAnnotation should be null; it is only used in the full AST.
         expect(o.elementAnnotation, isNull);
         expect(r.elementAnnotation, isNull);
-      } else if (o is ConstructorName && r is ConstructorName) {
-        fail('Not implemented for ${r.runtimeType} vs. ${o.runtimeType}');
       } else {
         fail('Not implemented for ${r.runtimeType} vs. ${o.runtimeType}');
       }
     }
   }
 
   void compareConstructorElements(ConstructorElementImpl resynthesized,
       ConstructorElementImpl original, String desc) {
     compareExecutableElements(resynthesized, original, desc);
-    // TODO(paulberry): test redirectedConstructor and constantInitializers
+    compareConstAstLists(resynthesized.constantInitializers,
+        original.constantInitializers, desc);
+    // TODO(paulberry): test redirectedConstructor
   }
 
   void compareElementAnnotations(ElementAnnotationImpl resynthesized,
       ElementAnnotationImpl original, String desc) {
     expect(resynthesized.element, isNotNull, reason: desc);
     expect(resynthesized.element.kind, original.element.kind, reason: desc);
     expect(resynthesized.element.location, original.element.location,
         reason: desc);
     expect(resynthesized.compilationUnit, isNotNull, reason: desc);
     expect(resynthesized.compilationUnit.location,
         original.compilationUnit.location,
         reason: desc);
     expect(resynthesized.annotationAst, isNotNull, reason: desc);
-    compareConstantAsts(
-        resynthesized.annotationAst, original.annotationAst, desc);
+    compareConstAsts(resynthesized.annotationAst, original.annotationAst, desc);
   }
 
   void compareElements(Element resynthesized, Element original, String desc) {
     expect(resynthesized, isNotNull);
     expect(resynthesized.kind, original.kind);
     expect(resynthesized.location, original.location, reason: desc);
     expect(resynthesized.name, original.name);
     expect(resynthesized.nameOffset, original.nameOffset, reason: desc);
     expect(resynthesized.documentationComment, original.documentationComment,
         reason: desc);
@@ skipping 310 matching lines @@
     expect(resynthesized.uriEnd, original.uriEnd, reason: desc);
   }
 
   void compareVariableElements(VariableElementImpl resynthesized,
       VariableElementImpl original, String desc) {
     compareElements(resynthesized, original, desc);
     compareTypes(resynthesized.type, original.type, desc);
     if (original is ConstVariableElement) {
       Expression initializer = resynthesized.constantInitializer;
       if (constantInitializersAreInvalid) {
-        expect(initializer, new isInstanceOf<SimpleIdentifier>(), reason: desc);
-        SimpleIdentifier identifier = initializer;
-        expect(identifier.staticElement, isNull, reason: desc);
+        _assertUnresolvedIdentifier(initializer, desc);
       } else {
-        compareConstantAsts(initializer, original.constantInitializer, desc);
+        compareConstAsts(initializer, original.constantInitializer, desc);
       }
     }
   }
 
   /**
    * Serialize the given [library] into a summary.  Then create a
    * [_TestSummaryResynthesizer] which can deserialize it, along with any
    * references it makes to `dart:core`.
    *
    * Errors will lead to a test failure unless [allowErrors] is `true`.
@@ skipping 1019 matching lines @@
   test_constructor_documented() {
     checkLibrary('''
 class C {
   /**
    * Docs
    */
   C();
 }''');
   }
 
+  test_constructor_initializers_field() {
+    checkLibrary('''
+class C {
+  final x;
+  const C() : x = 42;
+}
+''');
+  }
+
+  test_constructor_initializers_field_notConst() {
+    constantInitializersAreInvalid = true;
+    checkLibrary(
+        '''
+class C {
+  final x;
+  const A() : x = foo();
+}
+int foo() => 42;
+''',
+        allowErrors: true);
+  }
+
+  test_constructor_initializers_field_withParameter() {
+    checkLibrary('''
+class C {
+  final x;
+  const C(int p) : x = 1 + p;
+}
+''');
+  }
+
+  test_constructor_initializers_superInvocation_named() {
+    checkLibrary('''
+class A {
+  const A.aaa(int p);
+}
+class C extends A {
+  const C() : super.aaa(42);
+}
+''');
+  }
+
+  test_constructor_initializers_superInvocation_unnamed() {
+    checkLibrary('''
+class A {
+  const A(int p);
+}
+class C extends A {
+  const C.ccc() : super(42);
+}
+''');
+  }
+
+  test_constructor_initializers_thisInvocation_named() {
+    checkLibrary('''
+class C {
+  const C() : this.named(1, 'bbb');
+  const C.named(int a, String b);
+}
+''');
+  }
+
+  test_constructor_initializers_thisInvocation_unnamed() {
+    checkLibrary('''
+class C {
+  const C.named() : this(1, 'bbb');
+  const C(int a, String b);
+}
+''');
+  }
+
   test_core() {
     String uri = 'dart:core';
     LibraryElementImpl original =
         resolve2(analysisContext2.sourceFactory.forUri(uri));
     LibraryElementImpl resynthesized = resynthesizeLibraryElement(
         encodeLibraryElement(original), uri, original);
     checkLibraryElements(original, resynthesized);
   }
 
   test_enum_documented() {
@@ skipping 1037 matching lines @@
     _TestSummaryResynthesizer resynthesizer = encodeLibrary(original.library);
     ElementLocationImpl location = original.location;
     Element result = resynthesizer.getElement(location);
     checkMinimalResynthesisWork(resynthesizer, original.library);
     // Check that no other summaries needed to be resynthesized to resynthesize
     // the library element.
     expect(resynthesizer.resynthesisCount, 1);
     expect(result.location, location);
     return result;
   }
+
+  void _assertUnresolvedIdentifier(Expression initializer, String desc) {
+    expect(initializer, new isInstanceOf<SimpleIdentifier>(), reason: desc);
+    SimpleIdentifier identifier = initializer;
+    expect(identifier.staticElement, isNull, reason: desc);
+  }
 }
 
 class _TestSummaryResynthesizer extends SummaryResynthesizer {
   final Map<String, UnlinkedUnit> unlinkedSummaries;
   final Map<String, LinkedLibrary> linkedSummaries;
 
   /**
    * The set of uris for which unlinked summaries have been requested using
    * [getUnlinkedSummary].
    */
@@ skipping 33 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }