Complain about incorrect this/super constructor initializers.

pkg/front_end/lib/src/fasta/kernel/kernel_target.dart

 // Copyright (c) 2016, 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 fasta.kernel_target;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show File, IOSink;
 
@@ skipping 12 matching lines @@
         FieldInitializer,
         FunctionNode,
         Initializer,
         InvalidInitializer,
         Library,
         Name,
         NamedExpression,
         NullLiteral,
         ProcedureKind,
         Program,
-        RedirectingInitializer,
         Source,
         StringLiteral,
         SuperInitializer,
         Throw,
         TypeParameter,
         VariableDeclaration,
         VariableGet,
         VoidType;
 
 import 'package:kernel/binary/ast_to_binary.dart' show BinaryPrinter;
@@ skipping 32 matching lines @@
 import 'kernel_builder.dart'
     show
         Builder,
         ClassBuilder,
         InvalidTypeBuilder,
         KernelClassBuilder,
         KernelLibraryBuilder,
         KernelNamedTypeBuilder,
         KernelProcedureBuilder,
         LibraryBuilder,
+        MemberBuilder,
         MixinApplicationBuilder,
         NamedMixinApplicationBuilder,
         NamedTypeBuilder,
         TypeBuilder,
         TypeVariableBuilder;
 
 import 'verifier.dart' show verifyProgram;
 
 class KernelTarget extends TargetImplementation {
   final DillTarget dillTarget;
@@ skipping 252 matching lines @@
           AsyncMarker.Sync,
           ProcedureKind.Method,
           library,
           -1,
           -1,
           -1);
       library.addBuilder(mainBuilder.name, mainBuilder, -1);
       mainBuilder.body = new ExpressionStatement(
           new Throw(new StringLiteral("${errors.join('\n')}")));
     }
-    library.build();
+    library.build(loader.coreLibrary);
     return link(<Library>[library.library]);
   }
 
   /// Creates a program by combining [libraries] with the libraries of
   /// `dillTarget.loader.program`.
   Program link(List<Library> libraries) {
     Map<String, Source> uriToSource =
         new Map<String, Source>.from(this.uriToSource);
 
     final Program binary = dillTarget.loader.program;
@@ skipping 186 matching lines @@
     return new Constructor(
         new FunctionNode(new EmptyStatement(), returnType: const VoidType()),
         name: new Name(""));
   }
 
   void finishAllConstructors() {
     Class objectClass = this.objectClass;
     for (SourceClassBuilder builder in collectAllSourceClasses()) {
       Class cls = builder.target;
       if (cls != objectClass) {
-        finishConstructors(cls);
+        finishConstructors(builder);
       }
     }
     ticker.logMs("Finished constructors");
   }
 
   /// Ensure constructors of [cls] have the correct initializers and other
   /// requirements.
-  void finishConstructors(Class cls) {
+  void finishConstructors(SourceClassBuilder builder) {
+    Class cls = builder.target;
+
     /// Quotes below are from [Dart Programming Language Specification, 4th
     /// Edition](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf):
-    Constructor superTarget;
     List<Field> uninitializedFields = <Field>[];
     List<Field> nonFinalFields = <Field>[];
     for (Field field in cls.fields) {
       if (field.isInstanceMember && !field.isFinal) {
         nonFinalFields.add(field);
       }
       if (field.initializer == null) {
         uninitializedFields.add(field);
       }
     }
     Map<Constructor, List<FieldInitializer>> fieldInitializers =
         <Constructor, List<FieldInitializer>>{};
-    for (Constructor constructor in cls.constructors) {
-      if (!isRedirectingGenerativeConstructor(constructor)) {
+    Constructor superTarget;
+    builder.constructors.forEach((String name, Builder member) {
+      if (member.isFactory) return;
+      MemberBuilder constructorBuilder = member;
+      Constructor constructor = constructorBuilder.target;
+      if (!constructorBuilder.isRedirectingGenerativeConstructor) {
         /// >If no superinitializer is provided, an implicit superinitializer
         /// >of the form super() is added at the end of k’s initializer list,
         /// >unless the enclosing class is class Object.
-        if (!constructor.initializers.any(isSuperinitializerOrInvalid)) {
+        if (constructor.initializers.isEmpty) {
           superTarget ??= defaultSuperConstructor(cls);
           Initializer initializer;
           if (superTarget == null) {
             addError(
                 constructor.enclosingClass.fileUri,
                 constructor.fileOffset,
                 "${cls.superclass.name} has no constructor that takes no"
                 " arguments.");
             initializer = new InvalidInitializer();
           } else {
@@ skipping 20 matching lines @@
         if (constructor.isConst && nonFinalFields.isNotEmpty) {
           addError(constructor.enclosingClass.fileUri, constructor.fileOffset,
               "Constructor is marked 'const' so all fields must be final.");
           for (Field field in nonFinalFields) {
             addError(constructor.enclosingClass.fileUri, field.fileOffset,
                 "Field isn't final, but constructor is 'const'.");
           }
           nonFinalFields.clear();
         }
       }
-    }
+    });
     Set<Field> initializedFields;
     fieldInitializers.forEach(
         (Constructor constructor, List<FieldInitializer> initializers) {
       Iterable<Field> fields = initializers.map((i) => i.field);
       if (initializedFields == null) {
         initializedFields = new Set<Field>.from(fields);
       } else {
         initializedFields.addAll(fields);
       }
     });
@@ skipping 43 matching lines @@
     print("$sb");
     ticker.logMs("Dumped IR");
   }
 
   void verify() {
     errors.addAll(verifyProgram(program));
     ticker.logMs("Verified program");
   }
 }
 
-bool isSuperinitializerOrInvalid(Initializer initializer) {
-  return initializer is SuperInitializer || initializer is InvalidInitializer;
-}
-
-bool isRedirectingGenerativeConstructor(Constructor constructor) {
-  List<Initializer> initializers = constructor.initializers;
-  return initializers.length == 1 &&
-      initializers.single is RedirectingInitializer;
-}
-
 /// Looks for a constructor call that matches `super()` from a constructor in
 /// [cls]. Such a constructor may have optional arguments, but no required
 /// arguments.
 Constructor defaultSuperConstructor(Class cls) {
   Class superclass = cls.superclass;
   while (superclass != null && superclass.isMixinApplication) {
     superclass = superclass.superclass;
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }