Remove convertConstructors.

pkg/front_end/lib/src/fasta/kernel/kernel_procedure_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_procedure_builder;
 
 import 'package:kernel/ast.dart' show
     Arguments,
     AsyncMarker,
     Constructor,
@@ skipping 19 matching lines @@
     VoidType,
     setParents;
 
 import 'package:kernel/type_algebra.dart' show
     containsTypeVariable,
     substitute;
 
 import '../errors.dart' show
     internalError;
 
-import '../modifier.dart' show
-    abstractMask;
 
 import '../util/relativize.dart' show
     relativizeUri;
 
 import 'kernel_builder.dart' show
     ClassBuilder,
     ConstructorReferenceBuilder,
     FormalParameterBuilder,
     KernelFormalParameterBuilder,
     KernelLibraryBuilder,
     KernelTypeBuilder,
     KernelTypeVariableBuilder,
     MetadataBuilder,
     ProcedureBuilder,
-    TypeBuilder,
     TypeVariableBuilder,
     memberError;
 
 abstract class KernelFunctionBuilder
     extends ProcedureBuilder<KernelTypeBuilder> {
   FunctionNode function;
 
   Statement actualBody;
 
   KernelFunctionBuilder(
@@ skipping 126 matching lines @@
       procedure.function.parent = procedure;
       procedure.isAbstract = isAbstract;
       procedure.isStatic = isStatic;
       procedure.isExternal = isExternal;
       procedure.isConst = isConst;
       procedure.name = new Name(name, library);
     }
     return procedure;
   }
 
-  KernelFunctionBuilder toConstructor(String name,
-      List<TypeVariableBuilder> classTypeVariables) {
-    assert(procedure.name == null);
-    assert(actualBody == null);
-    if (isFactory) {
-      if (this.typeVariables != null) {
-        return memberError(target, "Factories can't be generic.");
-      }
-      List<KernelTypeVariableBuilder> typeVariables;
-      KernelTypeBuilder returnType = this.returnType;
-      List<FormalParameterBuilder> formals;
-      if (classTypeVariables != null) {
-        typeVariables = <KernelTypeVariableBuilder>[];
-        for (KernelTypeVariableBuilder variable in classTypeVariables) {
-          typeVariables.add(new KernelTypeVariableBuilder(
-                  variable.name, null, -1));
-        }
-        Map<TypeVariableBuilder, TypeBuilder> substitution =
-            <TypeVariableBuilder, TypeBuilder>{};
-        int i = 0;
-        for (KernelTypeVariableBuilder variable in classTypeVariables) {
-          substitution[variable] = typeVariables[i++].asTypeBuilder();
-        }
-        i = 0;
-        for (KernelTypeVariableBuilder variable in classTypeVariables) {
-          typeVariables[i++].bound = variable?.bound?.subst(substitution);
-        }
-        returnType = returnType?.subst(substitution);
-        i = 0;
-        if (this.formals != null) {
-          for (KernelFormalParameterBuilder formal in this.formals) {
-            KernelTypeBuilder type = formal.type?.subst(substitution);
-            if (type != formal.type) {
-              formals ??= this.formals.toList();
-              formals[i] = new KernelFormalParameterBuilder(formal.metadata,
-                  formal.modifiers, type, formal.name, formal.hasThis, null,
-                  -1);
-            }
-            i++;
-          }
-        }
-      }
-      formals ??= this.formals;
-      KernelProcedureBuilder factory = new KernelProcedureBuilder(
-          metadata, modifiers, returnType, name, typeVariables, formals,
-          actualAsyncModifier, kind, null, -1, redirectionTarget)
-          ..parent = parent;
-      factory.procedure.fileUri = procedure.fileUri;
-      return factory;
-    } else {
-      return new KernelConstructorBuilder(metadata, modifiers & ~abstractMask,
-          returnType, name, typeVariables, formals, null, -1)
-          ..parent = parent;
-    }
-  }
-
   Procedure get target => procedure;
 }
 
 // TODO(ahe): Move this to own file?
 class KernelConstructorBuilder extends KernelFunctionBuilder {
   final Constructor constructor = new Constructor(null);
 
   bool hasMovedSuperInitializer = false;
 
   SuperInitializer superInitializer;
@@ skipping 90 matching lines @@
         }
       }
       initializers.add(initializer..parent = constructor);
       initializers.add(superInitializer);
       return;
     }
     initializers.add(initializer);
     initializer.parent = constructor;
   }
 }