pkg/front_end/lib/src/fasta/builder/constructor_builder.dart - sdk.git - Git at Google

 // Copyright (c) 2019, 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.

 // @dart = 2.9

 import 'dart:core' hide MapEntry;

 import 'package:_fe_analyzer_shared/src/scanner/token.dart' show Token;

 import 'package:kernel/ast.dart';
 import 'package:kernel/core_types.dart';

 import '../constant_context.dart' show ConstantContext;

 import '../dill/dill_member_builder.dart';

 import '../kernel/body_builder.dart' show BodyBuilder;
 import '../kernel/class_hierarchy_builder.dart' show ClassMember;
 import '../kernel/expression_generator_helper.dart'
     show ExpressionGeneratorHelper;

 import '../kernel/kernel_builder.dart'
     show isRedirectingGenerativeConstructorImplementation;
 import '../kernel/kernel_target.dart' show ClonedFunctionNode;

 import '../loader.dart' show Loader;

 import '../messages.dart'
     show
         Message,
         messageMoreThanOneSuperInitializer,
         messageRedirectingConstructorWithAnotherInitializer,
         messageRedirectingConstructorWithMultipleRedirectInitializers,
         messageRedirectingConstructorWithSuperInitializer,
         messageSuperInitializerNotLast,
         noLength;

 import '../source/source_class_builder.dart';
 import '../source/source_library_builder.dart' show SourceLibraryBuilder;

 import 'builder.dart';
 import 'class_builder.dart';
 import 'field_builder.dart';
 import 'formal_parameter_builder.dart';
 import 'function_builder.dart';
 import 'library_builder.dart';
 import 'member_builder.dart';
 import 'metadata_builder.dart';
 import 'type_builder.dart';
 import 'type_variable_builder.dart';

 abstract class ConstructorBuilder implements FunctionBuilder {
   int get charOpenParenOffset;

   bool hasMovedSuperInitializer;

   SuperInitializer superInitializer;

   RedirectingInitializer redirectingInitializer;

   Token beginInitializers;

   @override
   ConstructorBuilder get actualOrigin;

   ConstructorBuilder get patchForTesting;

   Constructor get actualConstructor;

   @override
   ConstructorBuilder get origin;

   bool get isRedirectingGenerativeConstructor;

   /// The [Constructor] built by this builder.
   Constructor get constructor;

   void injectInvalidInitializer(Message message, int charOffset, int length,
       ExpressionGeneratorHelper helper);

   void addInitializer(
       Initializer initializer, ExpressionGeneratorHelper helper);

   void prepareInitializers();

   /// Infers the types of any untyped initializing formals.
   void inferFormalTypes();

   /// Registers field as being initialized by this constructor.
   ///
   /// The field can be initialized either via an initializing formal or via an
   /// entry in the constructor initializer list.
   void registerInitializedField(FieldBuilder fieldBuilder);

   /// Returns the fields registered as initialized by this constructor.
   ///
   /// Returns the set of fields previously registered via
   /// [registerInitializedField] and passes on the ownership of the collection
   /// to the caller.
   Set<FieldBuilder> takeInitializedFields();
 }

 class ConstructorBuilderImpl extends FunctionBuilderImpl
     implements ConstructorBuilder {
   final Constructor _constructor;

   Set<FieldBuilder> _initializedFields;

   @override
   final int charOpenParenOffset;

   @override
   bool hasMovedSuperInitializer = false;

   @override
   SuperInitializer superInitializer;

   @override
   RedirectingInitializer redirectingInitializer;

   @override
   Token beginInitializers;

   @override
   ConstructorBuilder actualOrigin;

   @override
   Constructor get actualConstructor => _constructor;

   ConstructorBuilderImpl(
       List<MetadataBuilder> metadata,
       int modifiers,
       TypeBuilder returnType,
       String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
       SourceLibraryBuilder compilationUnit,
       int startCharOffset,
       int charOffset,
       this.charOpenParenOffset,
       int charEndOffset,
       Member referenceFrom,
       [String nativeMethodName])
       : _constructor = new Constructor(null,
             fileUri: compilationUnit.fileUri,
             reference: referenceFrom?.reference)
           ..startFileOffset = startCharOffset
           ..fileOffset = charOffset
           ..fileEndOffset = charEndOffset
           ..isNonNullableByDefault = compilationUnit.isNonNullableByDefault,
         super(metadata, modifiers, returnType, name, typeVariables, formals,
             compilationUnit, charOffset, nativeMethodName);

   @override
   Member get readTarget => null;

   @override
   Member get writeTarget => null;

   @override
   Member get invokeTarget => constructor;

   @override
   Iterable<Member> get exportedMembers => [constructor];

   @override
   ConstructorBuilder get origin => actualOrigin ?? this;

   @override
   ConstructorBuilder get patchForTesting => dataForTesting?.patchForTesting;

   @override
   bool get isDeclarationInstanceMember => false;

   @override
   bool get isClassInstanceMember => false;

   @override
   bool get isConstructor => true;

   @override
   AsyncMarker get asyncModifier => AsyncMarker.Sync;

   @override
   ProcedureKind get kind => null;

   @override
   bool get isRedirectingGenerativeConstructor {
     return isRedirectingGenerativeConstructorImplementation(_constructor);
   }

   @override
   void buildMembers(
       LibraryBuilder library, void Function(Member, BuiltMemberKind) f) {
     Member member = build(library);
     f(member, BuiltMemberKind.Constructor);
   }

   @override
   Constructor build(SourceLibraryBuilder libraryBuilder) {
     if (_constructor.name == null) {
       _constructor.function = buildFunction(libraryBuilder);
       _constructor.function.parent = _constructor;
       _constructor.function.fileOffset = charOpenParenOffset;
       _constructor.function.fileEndOffset = _constructor.fileEndOffset;
       _constructor.function.typeParameters = const <TypeParameter>[];
       _constructor.isConst = isConst;
       _constructor.isExternal = isExternal;
       _constructor.name = new Name(name, libraryBuilder.library);
     }
     if (formals != null) {
       bool needsInference = false;
       for (FormalParameterBuilder formal in formals) {
         if (formal.type == null && formal.isInitializingFormal) {
           formal.variable.type = null;
           needsInference = true;
         }
       }
       if (needsInference) {
         assert(
             library == libraryBuilder,
             "Unexpected library builder ${libraryBuilder} for"
             " constructor $this in ${library}.");
         libraryBuilder.loader.typeInferenceEngine.toBeInferred[_constructor] =
             this;
       }
     }
     return _constructor;
   }

   @override
   void inferFormalTypes() {
     if (formals != null) {
       for (FormalParameterBuilder formal in formals) {
         if (formal.type == null && formal.isInitializingFormal) {
           formal.finalizeInitializingFormal(classBuilder);
         }
       }
     }
   }

   @override
   void buildOutlineExpressions(LibraryBuilder library, CoreTypes coreTypes) {
     super.buildOutlineExpressions(library, coreTypes);

     // For modular compilation purposes we need to include initializers
     // for const constructors into the outline.
     if (isConst && beginInitializers != null) {
       ClassBuilder classBuilder = parent;
       BodyBuilder bodyBuilder = library.loader
           .createBodyBuilderForOutlineExpression(
               library, classBuilder, this, classBuilder.scope, fileUri);
       bodyBuilder.constantContext = ConstantContext.required;
       bodyBuilder.parseInitializers(beginInitializers);
       bodyBuilder.resolveRedirectingFactoryTargets();
     }
     beginInitializers = null;
   }

   @override
   FunctionNode buildFunction(SourceLibraryBuilder library) {
     // According to the specification §9.3 the return type of a constructor
     // function is its enclosing class.
     FunctionNode functionNode = super.buildFunction(library);
     ClassBuilder enclosingClassBuilder = parent;
     Class enclosingClass = enclosingClassBuilder.cls;
     List<DartType> typeParameterTypes = <DartType>[];
     for (int i = 0; i < enclosingClass.typeParameters.length; i++) {
       TypeParameter typeParameter = enclosingClass.typeParameters[i];
       typeParameterTypes.add(
           new TypeParameterType.withDefaultNullabilityForLibrary(
               typeParameter, library.library));
     }
     functionNode.returnType = new InterfaceType(
         enclosingClass, library.nonNullable, typeParameterTypes);
     return functionNode;
   }

   @override
   Constructor get constructor => isPatch ? origin.constructor : _constructor;

   @override
   Member get member => constructor;

   @override
   void injectInvalidInitializer(Message message, int charOffset, int length,
       ExpressionGeneratorHelper helper) {
     List<Initializer> initializers = _constructor.initializers;
     Initializer lastInitializer = initializers.removeLast();
     assert(lastInitializer == superInitializer ||
         lastInitializer == redirectingInitializer);
     Initializer error = helper.buildInvalidInitializer(
         helper.buildProblem(message, charOffset, length));
     initializers.add(error..parent = _constructor);
     initializers.add(lastInitializer);
   }

   @override
   void addInitializer(
       Initializer initializer, ExpressionGeneratorHelper helper) {
     List<Initializer> initializers = _constructor.initializers;
     if (initializer is SuperInitializer) {
       if (superInitializer != null) {
         injectInvalidInitializer(messageMoreThanOneSuperInitializer,
             initializer.fileOffset, "super".length, helper);
       } else if (redirectingInitializer != null) {
         injectInvalidInitializer(
             messageRedirectingConstructorWithSuperInitializer,
             initializer.fileOffset,
             "super".length,
             helper);
       } else {
         initializers.add(initializer..parent = _constructor);
         superInitializer = initializer;
       }
     } else if (initializer is RedirectingInitializer) {
       if (superInitializer != null) {
         // Point to the existing super initializer.
         injectInvalidInitializer(
             messageRedirectingConstructorWithSuperInitializer,
             superInitializer.fileOffset,
             "super".length,
             helper);
       } else if (redirectingInitializer != null) {
         injectInvalidInitializer(
             messageRedirectingConstructorWithMultipleRedirectInitializers,
             initializer.fileOffset,
             noLength,
             helper);
       } else if (initializers.isNotEmpty) {
         // Error on all previous ones.
         for (int i = 0; i < initializers.length; i++) {
           Initializer initializer = initializers[i];
           int length = noLength;
           if (initializer is AssertInitializer) length = "assert".length;
           Initializer error = helper.buildInvalidInitializer(
               helper.buildProblem(
                   messageRedirectingConstructorWithAnotherInitializer,
                   initializer.fileOffset,
                   length));
           error.parent = _constructor;
           initializers[i] = error;
         }
         initializers.add(initializer..parent = _constructor);
         redirectingInitializer = initializer;
       } else {
         initializers.add(initializer..parent = _constructor);
         redirectingInitializer = initializer;
       }
     } else if (redirectingInitializer != null) {
       int length = noLength;
       if (initializer is AssertInitializer) length = "assert".length;
       injectInvalidInitializer(
           messageRedirectingConstructorWithAnotherInitializer,
           initializer.fileOffset,
           length,
           helper);
     } else if (superInitializer != null) {
       injectInvalidInitializer(messageSuperInitializerNotLast,
           initializer.fileOffset, noLength, helper);
     } else {
       initializers.add(initializer..parent = _constructor);
     }
   }

   @override
   int finishPatch() {
     if (!isPatch) return 0;

     // TODO(ahe): restore file-offset once we track both origin and patch file
     // URIs. See https://github.com/dart-lang/sdk/issues/31579
     origin.constructor.fileUri = fileUri;
     origin.constructor.startFileOffset = _constructor.startFileOffset;
     origin.constructor.fileOffset = _constructor.fileOffset;
     origin.constructor.fileEndOffset = _constructor.fileEndOffset;
     origin.constructor.annotations
         .forEach((m) => m.fileOffset = _constructor.fileOffset);

     origin.constructor.isExternal = _constructor.isExternal;
     origin.constructor.function = _constructor.function;
     origin.constructor.function.parent = origin.constructor;
     origin.constructor.initializers = _constructor.initializers;
     setParents(origin.constructor.initializers, origin.constructor);
     return 1;
   }

   @override
   void becomeNative(Loader loader) {
     _constructor.isExternal = true;
     super.becomeNative(loader);
   }

   @override
   void applyPatch(Builder patch) {
     if (patch is ConstructorBuilderImpl) {
       if (checkPatch(patch)) {
         patch.actualOrigin = this;
         dataForTesting?.patchForTesting = patch;
       }
     } else {
       reportPatchMismatch(patch);
     }
   }

   @override
   void prepareInitializers() {
     // For const constructors we parse initializers already at the outlining
     // stage, there is no easy way to make body building stage skip initializer
     // parsing, so we simply clear parsed initializers and rebuild them
     // again.
     // For when doing an experimental incremental compilation they are also
     // potentially done more than once (because it rebuilds the bodies of an old
     // compile), and so we also clear them.
     // Note: this method clears both initializers from the target Kernel node
     // and internal state associated with parsing initializers.
     _constructor.initializers.length = 0;
     redirectingInitializer = null;
     superInitializer = null;
     hasMovedSuperInitializer = false;
   }

   @override
   List<ClassMember> get localMembers =>
       throw new UnsupportedError('${runtimeType}.localMembers');

   @override
   List<ClassMember> get localSetters =>
       throw new UnsupportedError('${runtimeType}.localSetters');

   @override
   void registerInitializedField(FieldBuilder fieldBuilder) {
     (_initializedFields ??= {}).add(fieldBuilder);
   }

   @override
   Set<FieldBuilder> takeInitializedFields() {
     Set<FieldBuilder> result = _initializedFields;
     _initializedFields = null;
     return result;
   }
 }

 class SyntheticConstructorBuilder extends DillConstructorBuilder {
   MemberBuilderImpl _origin;
   ClonedFunctionNode _clonedFunctionNode;

   SyntheticConstructorBuilder(
       SourceClassBuilder parent, Constructor constructor,
       {MemberBuilder origin, ClonedFunctionNode clonedFunctionNode})
       : _origin = origin,
         _clonedFunctionNode = clonedFunctionNode,
         super(constructor, parent);

   void buildOutlineExpressions(
       LibraryBuilder libraryBuilder, CoreTypes coreTypes) {
     if (_origin != null) {
       // Ensure that default value expressions have been created for [_origin].
       _origin.buildOutlineExpressions(libraryBuilder, coreTypes);
       _clonedFunctionNode.cloneDefaultValues();
       _clonedFunctionNode = null;
       _origin = null;
     }
   }
 }
	// Copyright (c) 2019, 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.

	// @dart = 2.9

	import 'dart:core' hide MapEntry;

	import 'package:_fe_analyzer_shared/src/scanner/token.dart' show Token;

	import 'package:kernel/ast.dart';
	import 'package:kernel/core_types.dart';

	import '../constant_context.dart' show ConstantContext;

	import '../dill/dill_member_builder.dart';

	import '../kernel/body_builder.dart' show BodyBuilder;
	import '../kernel/class_hierarchy_builder.dart' show ClassMember;
	import '../kernel/expression_generator_helper.dart'
	show ExpressionGeneratorHelper;

	import '../kernel/kernel_builder.dart'
	show isRedirectingGenerativeConstructorImplementation;
	import '../kernel/kernel_target.dart' show ClonedFunctionNode;

	import '../loader.dart' show Loader;

	import '../messages.dart'
	show
	Message,
	messageMoreThanOneSuperInitializer,
	messageRedirectingConstructorWithAnotherInitializer,
	messageRedirectingConstructorWithMultipleRedirectInitializers,
	messageRedirectingConstructorWithSuperInitializer,
	messageSuperInitializerNotLast,
	noLength;

	import '../source/source_class_builder.dart';
	import '../source/source_library_builder.dart' show SourceLibraryBuilder;

	import 'builder.dart';
	import 'class_builder.dart';
	import 'field_builder.dart';
	import 'formal_parameter_builder.dart';
	import 'function_builder.dart';
	import 'library_builder.dart';
	import 'member_builder.dart';
	import 'metadata_builder.dart';
	import 'type_builder.dart';
	import 'type_variable_builder.dart';

	abstract class ConstructorBuilder implements FunctionBuilder {
	int get charOpenParenOffset;

	bool hasMovedSuperInitializer;

	SuperInitializer superInitializer;

	RedirectingInitializer redirectingInitializer;

	Token beginInitializers;

	@override
	ConstructorBuilder get actualOrigin;

	ConstructorBuilder get patchForTesting;

	Constructor get actualConstructor;

	@override
	ConstructorBuilder get origin;

	bool get isRedirectingGenerativeConstructor;

	/// The [Constructor] built by this builder.
	Constructor get constructor;

	void injectInvalidInitializer(Message message, int charOffset, int length,
	ExpressionGeneratorHelper helper);

	void addInitializer(
	Initializer initializer, ExpressionGeneratorHelper helper);

	void prepareInitializers();

	/// Infers the types of any untyped initializing formals.
	void inferFormalTypes();

	/// Registers field as being initialized by this constructor.
	///
	/// The field can be initialized either via an initializing formal or via an
	/// entry in the constructor initializer list.
	void registerInitializedField(FieldBuilder fieldBuilder);

	/// Returns the fields registered as initialized by this constructor.
	///
	/// Returns the set of fields previously registered via
	/// [registerInitializedField] and passes on the ownership of the collection
	/// to the caller.
	Set<FieldBuilder> takeInitializedFields();
	}

	class ConstructorBuilderImpl extends FunctionBuilderImpl
	implements ConstructorBuilder {
	final Constructor _constructor;

	Set<FieldBuilder> _initializedFields;

	@override
	final int charOpenParenOffset;

	@override
	bool hasMovedSuperInitializer = false;

	@override
	SuperInitializer superInitializer;

	@override
	RedirectingInitializer redirectingInitializer;

	@override
	Token beginInitializers;

	@override
	ConstructorBuilder actualOrigin;

	@override
	Constructor get actualConstructor => _constructor;

	ConstructorBuilderImpl(
	List<MetadataBuilder> metadata,
	int modifiers,
	TypeBuilder returnType,
	String name,
	List<TypeVariableBuilder> typeVariables,
	List<FormalParameterBuilder> formals,
	SourceLibraryBuilder compilationUnit,
	int startCharOffset,
	int charOffset,
	this.charOpenParenOffset,
	int charEndOffset,
	Member referenceFrom,
	[String nativeMethodName])
	: _constructor = new Constructor(null,
	fileUri: compilationUnit.fileUri,
	reference: referenceFrom?.reference)
	..startFileOffset = startCharOffset
	..fileOffset = charOffset
	..fileEndOffset = charEndOffset
	..isNonNullableByDefault = compilationUnit.isNonNullableByDefault,
	super(metadata, modifiers, returnType, name, typeVariables, formals,
	compilationUnit, charOffset, nativeMethodName);

	@override
	Member get readTarget => null;

	@override
	Member get writeTarget => null;

	@override
	Member get invokeTarget => constructor;

	@override
	Iterable<Member> get exportedMembers => [constructor];

	@override
	ConstructorBuilder get origin => actualOrigin ?? this;

	@override
	ConstructorBuilder get patchForTesting => dataForTesting?.patchForTesting;

	@override
	bool get isDeclarationInstanceMember => false;

	@override
	bool get isClassInstanceMember => false;

	@override
	bool get isConstructor => true;

	@override
	AsyncMarker get asyncModifier => AsyncMarker.Sync;

	@override
	ProcedureKind get kind => null;

	@override
	bool get isRedirectingGenerativeConstructor {
	return isRedirectingGenerativeConstructorImplementation(_constructor);
	}

	@override
	void buildMembers(
	LibraryBuilder library, void Function(Member, BuiltMemberKind) f) {
	Member member = build(library);
	f(member, BuiltMemberKind.Constructor);
	}

	@override
	Constructor build(SourceLibraryBuilder libraryBuilder) {
	if (_constructor.name == null) {
	_constructor.function = buildFunction(libraryBuilder);
	_constructor.function.parent = _constructor;
	_constructor.function.fileOffset = charOpenParenOffset;
	_constructor.function.fileEndOffset = _constructor.fileEndOffset;
	_constructor.function.typeParameters = const <TypeParameter>[];
	_constructor.isConst = isConst;
	_constructor.isExternal = isExternal;
	_constructor.name = new Name(name, libraryBuilder.library);
	}
	if (formals != null) {
	bool needsInference = false;
	for (FormalParameterBuilder formal in formals) {
	if (formal.type == null && formal.isInitializingFormal) {
	formal.variable.type = null;
	needsInference = true;
	}
	}
	if (needsInference) {
	assert(
	library == libraryBuilder,
	"Unexpected library builder ${libraryBuilder} for"
	" constructor $this in ${library}.");
	libraryBuilder.loader.typeInferenceEngine.toBeInferred[_constructor] =
	this;
	}
	}
	return _constructor;
	}

	@override
	void inferFormalTypes() {
	if (formals != null) {
	for (FormalParameterBuilder formal in formals) {
	if (formal.type == null && formal.isInitializingFormal) {
	formal.finalizeInitializingFormal(classBuilder);
	}
	}
	}
	}

	@override
	void buildOutlineExpressions(LibraryBuilder library, CoreTypes coreTypes) {
	super.buildOutlineExpressions(library, coreTypes);

	// For modular compilation purposes we need to include initializers
	// for const constructors into the outline.
	if (isConst && beginInitializers != null) {
	ClassBuilder classBuilder = parent;
	BodyBuilder bodyBuilder = library.loader
	.createBodyBuilderForOutlineExpression(
	library, classBuilder, this, classBuilder.scope, fileUri);
	bodyBuilder.constantContext = ConstantContext.required;
	bodyBuilder.parseInitializers(beginInitializers);
	bodyBuilder.resolveRedirectingFactoryTargets();
	}
	beginInitializers = null;
	}

	@override
	FunctionNode buildFunction(SourceLibraryBuilder library) {
	// According to the specification §9.3 the return type of a constructor
	// function is its enclosing class.
	FunctionNode functionNode = super.buildFunction(library);
	ClassBuilder enclosingClassBuilder = parent;
	Class enclosingClass = enclosingClassBuilder.cls;
	List<DartType> typeParameterTypes = <DartType>[];
	for (int i = 0; i < enclosingClass.typeParameters.length; i++) {
	TypeParameter typeParameter = enclosingClass.typeParameters[i];
	typeParameterTypes.add(
	new TypeParameterType.withDefaultNullabilityForLibrary(
	typeParameter, library.library));
	}
	functionNode.returnType = new InterfaceType(
	enclosingClass, library.nonNullable, typeParameterTypes);
	return functionNode;
	}

	@override
	Constructor get constructor => isPatch ? origin.constructor : _constructor;

	@override
	Member get member => constructor;

	@override
	void injectInvalidInitializer(Message message, int charOffset, int length,
	ExpressionGeneratorHelper helper) {
	List<Initializer> initializers = _constructor.initializers;
	Initializer lastInitializer = initializers.removeLast();
	assert(lastInitializer == superInitializer \|\|
	lastInitializer == redirectingInitializer);
	Initializer error = helper.buildInvalidInitializer(
	helper.buildProblem(message, charOffset, length));
	initializers.add(error..parent = _constructor);
	initializers.add(lastInitializer);
	}

	@override
	void addInitializer(
	Initializer initializer, ExpressionGeneratorHelper helper) {
	List<Initializer> initializers = _constructor.initializers;
	if (initializer is SuperInitializer) {
	if (superInitializer != null) {
	injectInvalidInitializer(messageMoreThanOneSuperInitializer,
	initializer.fileOffset, "super".length, helper);
	} else if (redirectingInitializer != null) {
	injectInvalidInitializer(
	messageRedirectingConstructorWithSuperInitializer,
	initializer.fileOffset,
	"super".length,
	helper);
	} else {
	initializers.add(initializer..parent = _constructor);
	superInitializer = initializer;
	}
	} else if (initializer is RedirectingInitializer) {
	if (superInitializer != null) {
	// Point to the existing super initializer.
	injectInvalidInitializer(
	messageRedirectingConstructorWithSuperInitializer,
	superInitializer.fileOffset,
	"super".length,
	helper);
	} else if (redirectingInitializer != null) {
	injectInvalidInitializer(
	messageRedirectingConstructorWithMultipleRedirectInitializers,
	initializer.fileOffset,
	noLength,
	helper);
	} else if (initializers.isNotEmpty) {
	// Error on all previous ones.
	for (int i = 0; i < initializers.length; i++) {
	Initializer initializer = initializers[i];
	int length = noLength;
	if (initializer is AssertInitializer) length = "assert".length;
	Initializer error = helper.buildInvalidInitializer(
	helper.buildProblem(
	messageRedirectingConstructorWithAnotherInitializer,
	initializer.fileOffset,
	length));
	error.parent = _constructor;
	initializers[i] = error;
	}
	initializers.add(initializer..parent = _constructor);
	redirectingInitializer = initializer;
	} else {
	initializers.add(initializer..parent = _constructor);
	redirectingInitializer = initializer;
	}
	} else if (redirectingInitializer != null) {
	int length = noLength;
	if (initializer is AssertInitializer) length = "assert".length;
	injectInvalidInitializer(
	messageRedirectingConstructorWithAnotherInitializer,
	initializer.fileOffset,
	length,
	helper);
	} else if (superInitializer != null) {
	injectInvalidInitializer(messageSuperInitializerNotLast,
	initializer.fileOffset, noLength, helper);
	} else {
	initializers.add(initializer..parent = _constructor);
	}
	}

	@override
	int finishPatch() {
	if (!isPatch) return 0;

	// TODO(ahe): restore file-offset once we track both origin and patch file
	// URIs. See https://github.com/dart-lang/sdk/issues/31579
	origin.constructor.fileUri = fileUri;
	origin.constructor.startFileOffset = _constructor.startFileOffset;
	origin.constructor.fileOffset = _constructor.fileOffset;
	origin.constructor.fileEndOffset = _constructor.fileEndOffset;
	origin.constructor.annotations
	.forEach((m) => m.fileOffset = _constructor.fileOffset);

	origin.constructor.isExternal = _constructor.isExternal;
	origin.constructor.function = _constructor.function;
	origin.constructor.function.parent = origin.constructor;
	origin.constructor.initializers = _constructor.initializers;
	setParents(origin.constructor.initializers, origin.constructor);
	return 1;
	}

	@override
	void becomeNative(Loader loader) {
	_constructor.isExternal = true;
	super.becomeNative(loader);
	}

	@override
	void applyPatch(Builder patch) {
	if (patch is ConstructorBuilderImpl) {
	if (checkPatch(patch)) {
	patch.actualOrigin = this;
	dataForTesting?.patchForTesting = patch;
	}
	} else {
	reportPatchMismatch(patch);
	}
	}

	@override
	void prepareInitializers() {
	// For const constructors we parse initializers already at the outlining
	// stage, there is no easy way to make body building stage skip initializer
	// parsing, so we simply clear parsed initializers and rebuild them
	// again.
	// For when doing an experimental incremental compilation they are also
	// potentially done more than once (because it rebuilds the bodies of an old
	// compile), and so we also clear them.
	// Note: this method clears both initializers from the target Kernel node
	// and internal state associated with parsing initializers.
	_constructor.initializers.length = 0;
	redirectingInitializer = null;
	superInitializer = null;
	hasMovedSuperInitializer = false;
	}

	@override
	List<ClassMember> get localMembers =>
	throw new UnsupportedError('${runtimeType}.localMembers');

	@override
	List<ClassMember> get localSetters =>
	throw new UnsupportedError('${runtimeType}.localSetters');

	@override
	void registerInitializedField(FieldBuilder fieldBuilder) {
	(_initializedFields ??= {}).add(fieldBuilder);
	}

	@override
	Set<FieldBuilder> takeInitializedFields() {
	Set<FieldBuilder> result = _initializedFields;
	_initializedFields = null;
	return result;
	}
	}

	class SyntheticConstructorBuilder extends DillConstructorBuilder {
	MemberBuilderImpl _origin;
	ClonedFunctionNode _clonedFunctionNode;

	SyntheticConstructorBuilder(
	SourceClassBuilder parent, Constructor constructor,
	{MemberBuilder origin, ClonedFunctionNode clonedFunctionNode})
	: _origin = origin,
	_clonedFunctionNode = clonedFunctionNode,
	super(constructor, parent);

	void buildOutlineExpressions(
	LibraryBuilder libraryBuilder, CoreTypes coreTypes) {
	if (_origin != null) {
	// Ensure that default value expressions have been created for [_origin].
	_origin.buildOutlineExpressions(libraryBuilder, coreTypes);
	_clonedFunctionNode.cloneDefaultValues();
	_clonedFunctionNode = null;
	_origin = null;
	}
	}
	}