Remove convertConstructors.

pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.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_library_builder;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show
     CloneVisitor;
 
 import '../errors.dart' show
     internalError;
 
 import '../loader.dart' show
     Loader;
 
 import '../modifier.dart' show
+    abstractMask,
     staticMask;
 
 import '../source/source_library_builder.dart' show
+    DeclarationBuilder,
     SourceLibraryBuilder;
 
 import '../source/source_class_builder.dart' show
     SourceClassBuilder;
 
 import '../util/relativize.dart' show
     relativizeUri;
 
 import 'kernel_builder.dart' show
     Builder,
     ClassBuilder,
     ConstructorReferenceBuilder,
     DynamicTypeBuilder,
     FormalParameterBuilder,
     FunctionTypeAliasBuilder,
+    KernelConstructorBuilder,
     KernelEnumBuilder,
     KernelFieldBuilder,
     KernelFormalParameterBuilder,
     KernelFunctionTypeAliasBuilder,
     KernelInvalidTypeBuilder,
     KernelMixinApplicationBuilder,
     KernelNamedMixinApplicationBuilder,
     KernelNamedTypeBuilder,
     KernelProcedureBuilder,
     KernelTypeBuilder,
     KernelTypeVariableBuilder,
     MemberBuilder,
     MetadataBuilder,
     MixedAccessor,
     NamedMixinApplicationBuilder,
     PrefixBuilder,
+    ProcedureBuilder,
+    TypeBuilder,
     TypeVariableBuilder;
 
 class KernelLibraryBuilder
     extends SourceLibraryBuilder<KernelTypeBuilder, Library> {
   final Library library;
 
   final List<Class> mixinApplicationClasses = <Class>[];
 
   final List<List> argumentsWithMissingDefaultValues = <List>[];
 
@@ skipping 36 matching lines @@
         new List<ConstructorReferenceBuilder>.from(constructorReferences),
         charOffset);
     constructorReferences.clear();
     classMembers.forEach((String name, MemberBuilder builder) {
       while (builder != null) {
         builder.parent = cls;
         builder = builder.next;
       }
     });
     // Nested declaration began in `OutlineBuilder.beginClassDeclaration`.
-    endNestedDeclaration().resolveTypes(typeVariables);
+    endNestedDeclaration().resolveTypes(typeVariables, this);
     addBuilder(className, cls, charOffset);
   }
 
   void addNamedMixinApplication(
       List<MetadataBuilder> metadata, String name,
       List<TypeVariableBuilder> typeVariables, int modifiers,
       KernelTypeBuilder mixinApplication, List<KernelTypeBuilder> interfaces,
       int charOffset) {
     NamedMixinApplicationBuilder builder =
         new KernelNamedMixinApplicationBuilder(metadata, name, typeVariables,
             modifiers, mixinApplication, interfaces, this, charOffset);
     // Nested declaration began in `OutlineBuilder.beginNamedMixinApplication`.
-    endNestedDeclaration().resolveTypes(typeVariables);
+    endNestedDeclaration().resolveTypes(typeVariables, this);
     addBuilder(name, builder, charOffset);
   }
 
   void addField(List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder type, String name, int charOffset) {
     addBuilder(name, new KernelFieldBuilder(
             metadata, type, name, modifiers, this, charOffset), charOffset);
   }
 
   void addProcedure(List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals, AsyncMarker asyncModifier,
       ProcedureKind kind, int charOffset, {bool isTopLevel}) {
     // Nested declaration began in `OutlineBuilder.beginMethod` or
     // `OutlineBuilder.beginTopLevelMethod`.
-    endNestedDeclaration().resolveTypes(typeVariables);
-    addBuilder(name,
-        new KernelProcedureBuilder(metadata, modifiers, returnType, name,
-            typeVariables, formals, asyncModifier, kind, this, charOffset),
-        charOffset);
+    endNestedDeclaration().resolveTypes(typeVariables, this);
+    ProcedureBuilder procedure;
+    if (!isTopLevel && isConstructorName(name, currentDeclaration.name)) {
+      int index = name.indexOf(".");
+      name = index == -1 ? "" : name.substring(index + 1);
+      procedure = new KernelConstructorBuilder(metadata,
+          modifiers & ~abstractMask, returnType, name, typeVariables, formals,
+          this, charOffset);
+    } else {
+      procedure = new KernelProcedureBuilder(metadata, modifiers, returnType,
+          name, typeVariables, formals, asyncModifier, kind, this, charOffset);
+    }
+    addBuilder(name, procedure, charOffset);
   }
 
   void addFactoryMethod(List<MetadataBuilder> metadata,
       ConstructorReferenceBuilder constructorName,
       List<FormalParameterBuilder> formals, AsyncMarker asyncModifier,
       ConstructorReferenceBuilder redirectionTarget, int charOffset) {
     // Nested declaration began in `OutlineBuilder.beginFactoryMethod`.
-    endNestedDeclaration().resolveTypes(null);
+    DeclarationBuilder<KernelTypeBuilder> factoryDeclaration =
+        endNestedDeclaration();
     String name = constructorName.name;
+    int index = name.indexOf(".");
+    name = index == -1 ? "" : name.substring(index + 1);
     assert(constructorName.suffix == null);
-    addBuilder(name,
-        new KernelProcedureBuilder(metadata, staticMask, null, name, null,
-            formals, asyncModifier, ProcedureKind.Factory, this, charOffset,
-            redirectionTarget), charOffset);
+    KernelProcedureBuilder procedure = new KernelProcedureBuilder(metadata,
+        staticMask, null, name, <TypeVariableBuilder>[], formals, asyncModifier,
+        ProcedureKind.Factory, this, charOffset, redirectionTarget);
+    currentDeclaration.addFactoryDeclaration(procedure, factoryDeclaration);
+    addBuilder(name, procedure, charOffset);
   }
 
   void addEnum(List<MetadataBuilder> metadata, String name,
       List<String> constants, int charOffset) {
     addBuilder(name,
         new KernelEnumBuilder(metadata, name, constants, this, charOffset),
         charOffset);
   }
 
   void addFunctionTypeAlias(List<MetadataBuilder> metadata,
       KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals, int charOffset) {
     FunctionTypeAliasBuilder typedef = new KernelFunctionTypeAliasBuilder(
         metadata, returnType, name, typeVariables, formals, this, charOffset);
     // Nested declaration began in `OutlineBuilder.beginFunctionTypeAlias`.
-    endNestedDeclaration().resolveTypes(typeVariables);
+    endNestedDeclaration().resolveTypes(typeVariables, this);
     addBuilder(name, typedef, charOffset);
   }
 
   KernelFormalParameterBuilder addFormalParameter(
       List<MetadataBuilder> metadata, int modifiers,
       KernelTypeBuilder type, String name, bool hasThis, int charOffset) {
     return new KernelFormalParameterBuilder(
         metadata, modifiers, type, name, hasThis, this, charOffset);
   }
 
@@ skipping 94 matching lines @@
             }
           }
           expression.value =
               defaultArgumentFrom(names[expression.name].initializer)
               ..parent = expression;
         }
       }
     }
     return argumentsWithMissingDefaultValues.length;
   }
+
+  List<TypeVariableBuilder> copyTypeVariables(
+      List<TypeVariableBuilder> original) {
+    List<TypeVariableBuilder> copy = <TypeVariableBuilder>[];
+    for (KernelTypeVariableBuilder variable in original) {
+      var newVariable = new KernelTypeVariableBuilder(

[Johnni Winther, 2017/02/13 09:50:35]

Add directly to [copy] and avoid the variable?

[ahe, 2017/02/13 14:58:53]

I'd like to keep it as is, as [copy] needs to be added to another list in a
following CL.

+          variable.name, this, variable.charOffset);
+      copy.add(newVariable);
+    }
+    Map<TypeVariableBuilder, TypeBuilder> substitution =
+        <TypeVariableBuilder, TypeBuilder>{};
+    int i = 0;
+    for (KernelTypeVariableBuilder variable in original) {
+      substitution[variable] = copy[i++].asTypeBuilder();
+    }
+    i = 0;
+    for (KernelTypeVariableBuilder variable in original) {
+      copy[i++].bound = variable.bound?.subst(substitution);
+    }
+    return copy;
+  }
 }
+
+bool isConstructorName(String name, String className) {
+  if (name.startsWith(className)) {
+    if (name.length == className.length) return true;
+    if (name.startsWith(".", className.length)) return true;
+  }
+  return false;
+}