Skip to content

Commit

Permalink
[cfe] Merge more Kernel*Builder classes into *Builder classes
Browse files Browse the repository at this point in the history 
* Remove EnumBuilder and rename KerneEnumBuilder to EnumBuilder
* Merge KernelInvalidTypeBuilder into InvalidTypeBuilder
* Merge KernelTypeAliasBuilder into TypeAliasBuilder
* Merge KernelTypeVariableBuilder into TypeVariableBuilder

Change-Id: Ie5554146fc0c073b48453bae446f36592e46ecab
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/110903
Reviewed-by: Dmitry Stefantsov <[email protected]>
Commit-Queue: Johnni Winther <[email protected]>
  • Loading branch information
@johnniwinther
johnniwinther authored and [email protected] committed Jul 31, 2019
1 parent fe2f826 commit 59aa4cd
Show file tree
Hide file tree
Showing 25 changed files with 751 additions and 847 deletions.
3 changes: 1 addition & 2 deletions pkg/front_end/lib/src/fasta/builder/class_builder.dart
View file
Original file line number Diff line number Diff line change
Expand Up @@ -112,7 +112,6 @@ import '../kernel/kernel_builder.dart'
KernelLibraryBuilder,
KernelMetadataBuilder,
NamedTypeBuilder,
KernelTypeVariableBuilder,
LibraryBuilder,
MemberBuilder,
MetadataBuilder,
Expand Down Expand Up @@ -1496,7 +1495,7 @@ abstract class ClassBuilder extends TypeDeclarationBuilder {
]);
} else if (typeVariables != null) {
int count = 0;
for (KernelTypeVariableBuilder t in patch.typeVariables) {
for (TypeVariableBuilder t in patch.typeVariables) {
typeVariables[count++].applyPatch(t);
}
}
Expand Down
343 changes: 341 additions & 2 deletions pkg/front_end/lib/src/fasta/builder/enum_builder.dart
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,8 +6,347 @@ library fasta.enum_builder;

import 'builder.dart' show ClassBuilder, MetadataBuilder;

abstract class EnumBuilder implements ClassBuilder {
List<EnumConstantInfo> get enumConstantInfos;
import 'package:kernel/ast.dart'
show
Arguments,
Class,
Constructor,
ConstructorInvocation,
DirectPropertyGet,
Expression,
Field,
FieldInitializer,
IntLiteral,
InterfaceType,
ListLiteral,
ProcedureKind,
ReturnStatement,
StaticGet,
StringLiteral,
SuperInitializer,
ThisExpression,
VariableGet;

import '../fasta_codes.dart'
show
LocatedMessage,
messageNoUnnamedConstructorInObject,
templateDuplicatedDeclaration,
templateDuplicatedDeclarationCause,
templateDuplicatedDeclarationSyntheticCause,
templateEnumConstantSameNameAsEnclosing;

import '../modifier.dart'
show
constMask,
finalMask,
hasInitializerMask,
initializingFormalMask,
staticMask;

import '../source/source_class_builder.dart' show SourceClassBuilder;

import '../kernel/kernel_builder.dart'
show
Declaration,
FormalParameterBuilder,
ClassBuilder,
ConstructorBuilder,
KernelFieldBuilder,
KernelLibraryBuilder,
NamedTypeBuilder,
ProcedureBuilder,
TypeBuilder,
LibraryBuilder,
MemberBuilder,
MetadataBuilder,
Scope;

import '../kernel/metadata_collector.dart';

class EnumBuilder extends SourceClassBuilder {
final List<EnumConstantInfo> enumConstantInfos;

final NamedTypeBuilder intType;

final NamedTypeBuilder stringType;

final NamedTypeBuilder objectType;

final NamedTypeBuilder listType;

EnumBuilder.internal(
List<MetadataBuilder> metadata,
String name,
Scope scope,
Scope constructors,
Class cls,
this.enumConstantInfos,
this.intType,
this.listType,
this.objectType,
this.stringType,
LibraryBuilder parent,
int startCharOffset,
int charOffset,
int charEndOffset)
: super(metadata, 0, name, null, null, null, null, scope, constructors,
parent, null, startCharOffset, charOffset, charEndOffset,
cls: cls);

factory EnumBuilder(
MetadataCollector metadataCollector,
List<MetadataBuilder> metadata,
String name,
List<EnumConstantInfo> enumConstantInfos,
KernelLibraryBuilder parent,
int startCharOffset,
int charOffset,
int charEndOffset) {
assert(enumConstantInfos == null || enumConstantInfos.isNotEmpty);
// TODO(ahe): These types shouldn't be looked up in scope, they come
// directly from dart:core.
TypeBuilder intType = new NamedTypeBuilder("int", null);
TypeBuilder stringType = new NamedTypeBuilder("String", null);
NamedTypeBuilder objectType = new NamedTypeBuilder("Object", null);
Class cls = new Class(name: name);
Map<String, MemberBuilder> members = <String, MemberBuilder>{};
Map<String, MemberBuilder> constructors = <String, MemberBuilder>{};
NamedTypeBuilder selfType = new NamedTypeBuilder(name, null);
TypeBuilder listType =
new NamedTypeBuilder("List", <TypeBuilder>[selfType]);

/// metadata class E {
/// final int index;
/// final String _name;
/// const E(this.index, this._name);
/// static const E id0 = const E(0, 'E.id0');
/// ...
/// static const E idn-1 = const E(n - 1, 'E.idn-1');
/// static const List<E> values = const <E>[id0, ..., idn-1];
/// String toString() => _name;
/// }
members["index"] = new KernelFieldBuilder(null, intType, "index",
finalMask | hasInitializerMask, parent, charOffset, charOffset);
members["_name"] = new KernelFieldBuilder(null, stringType, "_name",
finalMask | hasInitializerMask, parent, charOffset, charOffset);
ConstructorBuilder constructorBuilder = new ConstructorBuilder(
null,
constMask,
null,
"",
null,
<FormalParameterBuilder>[
new FormalParameterBuilder(null, initializingFormalMask, intType,
"index", parent, charOffset),
new FormalParameterBuilder(null, initializingFormalMask, stringType,
"_name", parent, charOffset)
],
parent,
charOffset,
charOffset,
charOffset,
charEndOffset);
constructors[""] = constructorBuilder;
KernelFieldBuilder valuesBuilder = new KernelFieldBuilder(
null,
listType,
"values",
constMask | staticMask | hasInitializerMask,
parent,
charOffset,
charOffset);
members["values"] = valuesBuilder;
ProcedureBuilder toStringBuilder = new ProcedureBuilder(
null,
0,
stringType,
"toString",
null,
null,
ProcedureKind.Method,
parent,
charOffset,
charOffset,
charOffset,
charEndOffset);
members["toString"] = toStringBuilder;
String className = name;
if (enumConstantInfos != null) {
for (int i = 0; i < enumConstantInfos.length; i++) {
EnumConstantInfo enumConstantInfo = enumConstantInfos[i];
List<MetadataBuilder> metadata = enumConstantInfo.metadata;
String name = enumConstantInfo.name;
String documentationComment = enumConstantInfo.documentationComment;
MemberBuilder existing = members[name];
if (existing != null) {
// The existing declaration is synthetic if it has the same
// charOffset as the enclosing enum.
bool isSynthetic = existing.charOffset == charOffset;
List<LocatedMessage> context = isSynthetic
? <LocatedMessage>[
templateDuplicatedDeclarationSyntheticCause
.withArguments(name)
.withLocation(
parent.fileUri, charOffset, className.length)
]
: <LocatedMessage>[
templateDuplicatedDeclarationCause
.withArguments(name)
.withLocation(
parent.fileUri, existing.charOffset, name.length)
];
parent.addProblem(templateDuplicatedDeclaration.withArguments(name),
enumConstantInfo.charOffset, name.length, parent.fileUri,
context: context);
enumConstantInfos[i] = null;
} else if (name == className) {
parent.addProblem(
templateEnumConstantSameNameAsEnclosing.withArguments(name),
enumConstantInfo.charOffset,
name.length,
parent.fileUri);
}
KernelFieldBuilder fieldBuilder = new KernelFieldBuilder(
metadata,
selfType,
name,
constMask | staticMask | hasInitializerMask,
parent,
enumConstantInfo.charOffset,
enumConstantInfo.charOffset);
metadataCollector?.setDocumentationComment(
fieldBuilder.target, documentationComment);
members[name] = fieldBuilder..next = existing;
}
}
final int startCharOffsetComputed =
metadata == null ? startCharOffset : metadata.first.charOffset;
EnumBuilder enumBuilder = new EnumBuilder.internal(
metadata,
name,
new Scope(members, null, parent.scope, "enum $name",
isModifiable: false),
new Scope(constructors, null, null, name, isModifiable: false),
cls,
enumConstantInfos,
intType,
listType,
objectType,
stringType,
parent,
startCharOffsetComputed,
charOffset,
charEndOffset);
void setParent(String name, MemberBuilder builder) {
do {
builder.parent = enumBuilder;
builder = builder.next;
} while (builder != null);
}

members.forEach(setParent);
constructors.forEach(setParent);
selfType.bind(enumBuilder);
return enumBuilder;
}

TypeBuilder get mixedInType => null;

InterfaceType buildType(LibraryBuilder library, List<TypeBuilder> arguments) {
return cls.rawType;
}

@override
Class build(KernelLibraryBuilder libraryBuilder, LibraryBuilder coreLibrary) {
cls.isEnum = true;
intType.resolveIn(coreLibrary.scope, charOffset, fileUri, libraryBuilder);
stringType.resolveIn(
coreLibrary.scope, charOffset, fileUri, libraryBuilder);
objectType.resolveIn(
coreLibrary.scope, charOffset, fileUri, libraryBuilder);
listType.resolveIn(coreLibrary.scope, charOffset, fileUri, libraryBuilder);

KernelFieldBuilder indexFieldBuilder = firstMemberNamed("index");
Field indexField = indexFieldBuilder.build(libraryBuilder);
KernelFieldBuilder nameFieldBuilder = firstMemberNamed("_name");
Field nameField = nameFieldBuilder.build(libraryBuilder);
ProcedureBuilder toStringBuilder = firstMemberNamed("toString");
toStringBuilder.body = new ReturnStatement(
new DirectPropertyGet(new ThisExpression(), nameField));
List<Expression> values = <Expression>[];
if (enumConstantInfos != null) {
for (EnumConstantInfo enumConstantInfo in enumConstantInfos) {
if (enumConstantInfo != null) {
Declaration declaration = firstMemberNamed(enumConstantInfo.name);
if (declaration.isField) {
KernelFieldBuilder field = declaration;
values.add(new StaticGet(field.build(libraryBuilder)));
}
}
}
}
KernelFieldBuilder valuesBuilder = firstMemberNamed("values");
valuesBuilder.build(libraryBuilder);
valuesBuilder.initializer =
new ListLiteral(values, typeArgument: cls.rawType, isConst: true);
ConstructorBuilder constructorBuilder = constructorScopeBuilder[""];
Constructor constructor = constructorBuilder.build(libraryBuilder);
constructor.initializers.insert(
0,
new FieldInitializer(indexField,
new VariableGet(constructor.function.positionalParameters[0]))
..parent = constructor);
constructor.initializers.insert(
1,
new FieldInitializer(nameField,
new VariableGet(constructor.function.positionalParameters[1]))
..parent = constructor);
ClassBuilder objectClass = objectType.declaration;
MemberBuilder superConstructor = objectClass.findConstructorOrFactory(
"", charOffset, fileUri, libraryBuilder);
if (superConstructor == null || !superConstructor.isConstructor) {
// TODO(ahe): Ideally, we would also want to check that [Object]'s
// unnamed constructor requires no arguments. But that information isn't
// always available at this point, and it's not really a situation that
// can happen unless you start modifying the SDK sources.
library.addProblem(messageNoUnnamedConstructorInObject,
objectClass.charOffset, objectClass.name.length, objectClass.fileUri);
} else {
constructor.initializers.add(
new SuperInitializer(superConstructor.target, new Arguments.empty())
..parent = constructor);
}
int index = 0;
if (enumConstantInfos != null) {
for (EnumConstantInfo enumConstantInfo in enumConstantInfos) {
if (enumConstantInfo != null) {
String constant = enumConstantInfo.name;
Declaration declaration = firstMemberNamed(constant);
KernelFieldBuilder field;
if (declaration.isField) {
field = declaration;
} else {
continue;
}
Arguments arguments = new Arguments(<Expression>[
new IntLiteral(index++),
new StringLiteral("$name.$constant")
]);
field.initializer =
new ConstructorInvocation(constructor, arguments, isConst: true);
}
}
}
return super.build(libraryBuilder, coreLibrary);
}

@override
Declaration findConstructorOrFactory(
String name, int charOffset, Uri uri, LibraryBuilder library) {
return null;
}
}

class EnumConstantInfo {
Expand Down
3 changes: 1 addition & 2 deletions pkg/front_end/lib/src/fasta/builder/function_type_builder.dart
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,7 +24,6 @@ import '../problems.dart' show unsupported;
import '../kernel/kernel_builder.dart'
show
FormalParameterBuilder,
KernelTypeVariableBuilder,
LibraryBuilder,
TypeBuilder,
TypeVariableBuilder;
Expand Down Expand Up @@ -98,7 +97,7 @@ class FunctionTypeBuilder extends TypeBuilder {
List<TypeParameter> typeParameters;
if (typeVariables != null) {
typeParameters = <TypeParameter>[];
for (KernelTypeVariableBuilder t in typeVariables) {
for (TypeVariableBuilder t in typeVariables) {
typeParameters.add(t.parameter);
}
}
Expand Down
Loading

0 comments on commit 59aa4cd

Please sign in to comment.