Version 2.17.0-53.0.dev
Merge commit 'befff2871ff4becd4c4c914fe329e97db39887d0' into 'dev'
diff --git a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
index 7f4e321..027c7bb 100644
--- a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
@@ -2789,6 +2789,16 @@
r"""Try removing the factory constructor declaration.""");
// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeEnumEntryWithTypeArgumentsWithoutArguments =
+ messageEnumEntryWithTypeArgumentsWithoutArguments;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageEnumEntryWithTypeArgumentsWithoutArguments =
+ const MessageCode("EnumEntryWithTypeArgumentsWithoutArguments",
+ problemMessage:
+ r"""Missing arguments in enum constructor invocation.""");
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
const Code<Null> codeEnumInClass = messageEnumInClass;
// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index c6e63d6..be0762c 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -82,7 +82,7 @@
/// TODO(scheglov) Clean up the list of implicitly analyzed files.
class AnalysisDriver implements AnalysisDriverGeneric {
/// The version of data format, should be incremented on every format change.
- static const int DATA_VERSION = 200;
+ static const int DATA_VERSION = 201;
/// The number of exception contexts allowed to write. Once this field is
/// zero, we stop writing any new exception contexts in this process.
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 5bbe3e7..6101710 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -3225,6 +3225,20 @@
setModifier(Modifier.STATIC, isStatic);
}
+ /// Return `true` if this element is a synthetic enum field.
+ ///
+ /// It is synthetic because it is not written explicitly in code, but it
+ /// is different from other synthetic fields, because its getter is also
+ /// synthetic.
+ ///
+ /// Such fields are `index`, `_name`, and `values`.
+ bool get isSyntheticEnumField {
+ return enclosingElement is EnumElementImpl &&
+ isSynthetic &&
+ getter?.isSynthetic == true &&
+ setter == null;
+ }
+
@override
ElementKind get kind => ElementKind.FIELD;
diff --git a/pkg/analyzer/lib/src/summary2/bundle_writer.dart b/pkg/analyzer/lib/src/summary2/bundle_writer.dart
index 87b340f..489d45d 100644
--- a/pkg/analyzer/lib/src/summary2/bundle_writer.dart
+++ b/pkg/analyzer/lib/src/summary2/bundle_writer.dart
@@ -178,7 +178,8 @@
_writeTypeParameters(element.typeParameters, () {
_writeList(
element.fields.where((e) {
- return !e.isSynthetic || const {'index', 'values'}.contains(e.name);
+ return !e.isSynthetic ||
+ e is FieldElementImpl && e.isSyntheticEnumField;
}).toList(),
_writeFieldElement,
);
diff --git a/pkg/analyzer/lib/src/summary2/element_builder.dart b/pkg/analyzer/lib/src/summary2/element_builder.dart
index d2ef4a6..8bad34e 100644
--- a/pkg/analyzer/lib/src/summary2/element_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/element_builder.dart
@@ -184,7 +184,7 @@
node.declaredElement = element;
_linker.elementNodes[element] = node;
- var reference = _enclosingContext.addConstructor(name, element);
+ var reference = _enclosingContext.addConstructor(element);
_buildExecutableElementChildren(
reference: reference,
element: element,
@@ -214,47 +214,30 @@
var reference = _enclosingContext.addEnum(name, element);
_libraryBuilder.localScope.declare(name, reference);
+ var usedNames = <String>{
+ ...node.constants.map((e) => e.name.name),
+ };
+
+ String generateUniqueName(String base) {
+ if (usedNames.add(base)) {
+ return base;
+ }
+ for (var index = 2;; index++) {
+ var name = '$base$index';
+ if (usedNames.add(name)) {
+ return name;
+ }
+ }
+ }
+
var holder = _EnclosingContext(
reference,
element,
hasConstConstructor: true,
);
- // Build the 'index' field.
- var indexField = ConstFieldElementImpl('index', -1)
- ..isSynthetic = true
- ..isFinal = true;
- holder.addNonSyntheticField(indexField);
-
- var constructorIndexParameter = FieldFormalParameterElementImpl(
- name: 'index',
- nameOffset: -1,
- parameterKind: ParameterKind.REQUIRED,
- )..field = indexField;
-
- var constructorNameParameter = ParameterElementImpl(
- name: 'name',
- nameOffset: -1,
- parameterKind: ParameterKind.REQUIRED,
- );
-
- var constructorName = '_';
- if (node.constants.any((c) => c.name.name == '_')) {
- constructorName = '_1';
- }
-
- var constructorReference =
- reference.getChild('@constructor').getChild(constructorName);
- var constructor = ConstructorElementImpl(constructorName, -1)
- ..isConst = true
- ..isSynthetic = true
- ..parameters = [
- constructorIndexParameter,
- constructorNameParameter,
- ]
- ..reference = constructorReference;
- constructorReference.element = constructor;
- element.constructors = [constructor];
+ var needsImplicitConstructor =
+ !node.members.any((e) => e is ConstructorDeclaration);
// Build fields for all enum constants.
var constants = node.constants;
@@ -274,6 +257,10 @@
_unitElement,
constant.metadata,
);
+
+ var constructorSelector = constant.arguments?.constructorSelector;
+ var constructorName = constructorSelector?.name.name ?? '';
+
var initializer = astFactory.instanceCreationExpression(
null,
astFactory.constructorName(
@@ -298,6 +285,7 @@
StringToken(TokenType.STRING, "'$name'", 0),
name,
),
+ ...?constant.arguments?.argumentList.arguments,
],
Tokens.closeParenthesis(),
),
@@ -379,11 +367,56 @@
// node.withClause?.accept(this);
// node.implementsClause?.accept(this);
+ // Build the 'index' field.
+ var indexField = ConstFieldElementImpl('index', -1)
+ ..isFinal = true
+ ..isSynthetic = true;
+ holder.addNonSyntheticField(indexField);
+
+ // Build the 'name' field.
+ var nameField = ConstFieldElementImpl(generateUniqueName('_name'), -1)
+ ..isFinal = true
+ ..isSynthetic = true;
+ holder.addNonSyntheticField(nameField);
+
_withEnclosing(holder, () {
node.typeParameters?.accept(this);
_visitPropertyFirst<FieldDeclaration>(node.members);
});
+ FieldFormalParameterElementImpl newConstructorIndexParameter() {
+ return FieldFormalParameterElementImpl(
+ name: 'index',
+ nameOffset: -1,
+ parameterKind: ParameterKind.REQUIRED,
+ )..field = indexField;
+ }
+
+ FieldFormalParameterElementImpl newConstructorNameParameter() {
+ return FieldFormalParameterElementImpl(
+ name: nameField.name,
+ nameOffset: -1,
+ parameterKind: ParameterKind.REQUIRED,
+ )..field = nameField;
+ }
+
+ if (needsImplicitConstructor) {
+ holder.addConstructor(
+ ConstructorElementImpl('', -1)
+ ..isConst = true
+ ..isSynthetic = true
+ ..parameters = [
+ newConstructorIndexParameter(),
+ newConstructorNameParameter(),
+ ],
+ );
+ } else {
+ for (var constructor in holder.constructors) {
+ constructor.parameters.insert(0, newConstructorIndexParameter());
+ constructor.parameters.insert(1, newConstructorNameParameter());
+ }
+ }
+
MethodElementImpl? syntheticToStringMethod;
if (holder.getMethod('toString').element == null) {
syntheticToStringMethod = MethodElementImpl('toString', -1)
@@ -395,18 +428,18 @@
ImplicitEnumNodes(
element: element,
indexField: indexField,
+ nameField: nameField,
valuesTypeNode: valuesTypeNode,
valuesField: valuesField,
- constructorIndexParameter: constructorIndexParameter,
- constructorNameParameter: constructorNameParameter,
syntheticToStringMethod: syntheticToStringMethod,
),
);
- element.typeParameters = holder.typeParameters;
element.accessors = holder.propertyAccessors;
+ element.constructors = holder.constructors;
element.fields = holder.properties.whereType<FieldElementImpl>().toList();
element.methods = holder.methods;
+ element.typeParameters = holder.typeParameters;
// TODO(scheglov) resolve field formals
}
@@ -1145,7 +1178,6 @@
if (holder.constructors.isEmpty) {
holder.addConstructor(
- '',
ConstructorElementImpl('', -1)..isSynthetic = true,
);
}
@@ -1400,9 +1432,9 @@
return _bindReference('@class', name, element);
}
- Reference addConstructor(String name, ConstructorElementImpl element) {
+ Reference addConstructor(ConstructorElementImpl element) {
constructors.add(element);
- return _bindReference('@constructor', name, element);
+ return _bindReference('@constructor', element.name, element);
}
Reference addEnum(String name, EnumElementImpl element) {
diff --git a/pkg/analyzer/lib/src/summary2/informative_data.dart b/pkg/analyzer/lib/src/summary2/informative_data.dart
index f8c9fdb..1ae0a1c 100644
--- a/pkg/analyzer/lib/src/summary2/informative_data.dart
+++ b/pkg/analyzer/lib/src/summary2/informative_data.dart
@@ -242,8 +242,9 @@
void _applyToConstructors(
List<ConstructorElement> elementList,
- List<_InfoConstructorDeclaration> infoList,
- ) {
+ List<_InfoConstructorDeclaration> infoList, {
+ bool ofEnum = false,
+ }) {
forCorrespondingPairs<ConstructorElement, _InfoConstructorDeclaration>(
elementList,
infoList,
@@ -254,8 +255,10 @@
element.nameOffset = info.nameOffset;
element.nameEnd = info.nameEnd;
element.documentationComment = info.documentationComment;
+
+ var formalParameters = element.parameters_unresolved;
_applyToFormalParameters(
- element.parameters_unresolved,
+ ofEnum ? formalParameters.skip(2).toList() : formalParameters,
info.parameters,
);
@@ -285,7 +288,7 @@
element.typeParameters_unresolved,
info.typeParameters,
);
- _applyToConstructors(element.constructors, info.constructors);
+ _applyToConstructors(element.constructors, info.constructors, ofEnum: true);
_applyToFields(element.fields, info.fields);
_applyToAccessors(element.accessors, info.accessors);
_applyToMethods(element.methods, info.methods);
@@ -1296,6 +1299,7 @@
_writeDocumentationComment(node);
_writeOffsets(
metadata: node.metadata,
+ enumConstantArguments: node.arguments?.argumentList,
);
}
@@ -1429,6 +1433,7 @@
NodeList<ConstructorInitializer>? constructorInitializers,
NodeList<EnumConstantDeclaration>? enumConstants,
TypeAnnotation? aliasedType,
+ ArgumentList? enumConstantArguments,
}) {
var collector = _OffsetsCollector();
@@ -1480,6 +1485,7 @@
addTypeParameters(aliasedType.typeParameters);
addFormalParameters(aliasedType.parameters);
}
+ enumConstantArguments?.arguments.accept(collector);
sink.writeUint30List(collector.offsets);
}
@@ -1655,11 +1661,17 @@
_OffsetsApplier(this._iterator);
void applyToConstantInitializer(Element element) {
- if (element is ConstVariableElement) {
+ if (element is ConstFieldElementImpl && element.isEnumConstant) {
var initializer = element.constantInitializer;
- if (initializer != null) {
- initializer.accept(this);
+ if (initializer is InstanceCreationExpression) {
+ var arguments = initializer.argumentList.arguments;
+ // Skip synthetic `index` and `name` arguments.
+ for (var argument in arguments.skip(2)) {
+ argument.accept(this);
+ }
}
+ } else if (element is ConstVariableElement) {
+ element.constantInitializer?.accept(this);
}
}
diff --git a/pkg/analyzer/lib/src/summary2/library_builder.dart b/pkg/analyzer/lib/src/summary2/library_builder.dart
index e8b40c2..765c9dc 100644
--- a/pkg/analyzer/lib/src/summary2/library_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/library_builder.dart
@@ -23,19 +23,17 @@
class ImplicitEnumNodes {
final EnumElementImpl element;
final FieldElementImpl indexField;
+ final FieldElementImpl nameField;
final ast.NamedTypeImpl valuesTypeNode;
final ConstFieldElementImpl valuesField;
- final ParameterElementImpl constructorIndexParameter;
- final ParameterElementImpl constructorNameParameter;
final MethodElementImpl? syntheticToStringMethod;
ImplicitEnumNodes({
required this.element,
required this.indexField,
+ required this.nameField,
required this.valuesTypeNode,
required this.valuesField,
- required this.constructorIndexParameter,
- required this.constructorNameParameter,
required this.syntheticToStringMethod,
});
}
@@ -139,6 +137,7 @@
var typeProvider = element.typeProvider;
for (var enum_ in implicitEnumNodes) {
enum_.indexField.type = typeProvider.intType;
+ enum_.nameField.type = typeProvider.stringType;
var valuesType = typeProvider.listType(
element.typeSystem.instantiateToBounds2(
classElement: enum_.element,
@@ -147,9 +146,14 @@
);
enum_.valuesTypeNode.type = valuesType;
enum_.valuesField.type = valuesType;
- enum_.constructorIndexParameter.type = typeProvider.intType;
- enum_.constructorNameParameter.type = typeProvider.stringType;
enum_.syntheticToStringMethod?.returnType = typeProvider.stringType;
+ for (var constructor in enum_.element.constructors) {
+ var parameters = constructor.parameters;
+ if (parameters.length >= 2) {
+ parameters[0].impl.type = typeProvider.intType;
+ parameters[1].impl.type = typeProvider.stringType;
+ }
+ }
}
}
@@ -334,3 +338,9 @@
required this.element,
});
}
+
+extension on ParameterElement {
+ ParameterElementImpl get impl {
+ return this as ParameterElementImpl;
+ }
+}
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index 4c29cd7..3e35554 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -8301,8 +8301,6 @@
codeLength: 26
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant aaa @11
codeOffset: 11
codeLength: 3
@@ -8320,11 +8318,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -8349,11 +8347,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -8378,11 +8376,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -8410,21 +8408,24 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
codeOffset: null
codeLength: null
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
codeOffset: null
codeLength: null
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get aaa @-1
returnType: E
synthetic static get bbb @-1
@@ -8433,6 +8434,10 @@
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -13581,8 +13586,6 @@
enum E @30
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant a @33
type: E
constantInitializer
@@ -13598,11 +13601,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -13625,11 +13628,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -13652,11 +13655,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -13684,17 +13687,20 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get a @-1
returnType: E
synthetic static get b @-1
@@ -13703,6 +13709,10 @@
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -15900,8 +15910,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant a @8
type: E
constantInitializer
@@ -15917,11 +15925,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -15944,11 +15952,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -15971,11 +15979,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -16003,17 +16011,20 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get a @-1
returnType: E
synthetic static get b @-1
@@ -16022,6 +16033,10 @@
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -16054,8 +16069,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant a @8
type: E
constantInitializer
@@ -16071,11 +16084,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -16095,21 +16108,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get a @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -17067,8 +17087,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant a @8
type: E
constantInitializer
@@ -17084,11 +17102,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -17111,11 +17129,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -17139,31 +17157,36 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get a @-1
returnType: E
synthetic static get b @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
enum E @19
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant c @22
type: E
constantInitializer
@@ -17179,11 +17202,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -17206,11 +17229,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -17233,11 +17256,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -17265,17 +17288,20 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get c @-1
returnType: E
synthetic static get d @-1
@@ -17284,6 +17310,10 @@
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -17505,24 +17535,314 @@
''');
}
- test_enum_documented() async {
- var library = await checkLibrary('''
-// Extra comment so doc comment offset != 0
-/**
- * Docs
- */
-enum E { v }''');
+ test_enum_constant_inference() async {
+ var library = await checkLibrary(r'''
+enum E<T> {
+ int(1), string('2');
+ E(T a);
+}
+''');
checkElementText(library, r'''
library
definingUnit
enums
- enum E @65
- documentationComment: /**\n * Docs\n */
+ enum E @5
+ typeParameters
+ covariant T @7
+ defaultType: dynamic
supertype: Enum
fields
+ static const enumConstant int @14
+ type: E<int>
+ constantInitializer
+ InstanceCreationExpression
+ argumentList: ArgumentList
+ arguments
+ IntegerLiteral
+ literal: 0 @0
+ staticType: int
+ SimpleStringLiteral
+ literal: 'int' @0
+ IntegerLiteral
+ literal: 1 @18
+ staticType: int
+ leftParenthesis: ( @0
+ rightParenthesis: ) @0
+ constructorName: ConstructorName
+ name: SimpleIdentifier
+ staticElement: ConstructorMember
+ base: self::@enum::E::@constructor::•
+ substitution: {T: int}
+ staticType: null
+ token: @-1
+ period: . @0
+ staticElement: ConstructorMember
+ base: self::@enum::E::@constructor::•
+ substitution: {T: int}
+ type: NamedType
+ name: SimpleIdentifier
+ staticElement: self::@enum::E
+ staticType: null
+ token: E @-1
+ type: E<int>
+ staticType: E<int>
+ static const enumConstant string @22
+ type: E<String>
+ constantInitializer
+ InstanceCreationExpression
+ argumentList: ArgumentList
+ arguments
+ IntegerLiteral
+ literal: 1 @0
+ staticType: int
+ SimpleStringLiteral
+ literal: 'string' @0
+ SimpleStringLiteral
+ literal: '2' @29
+ leftParenthesis: ( @0
+ rightParenthesis: ) @0
+ constructorName: ConstructorName
+ name: SimpleIdentifier
+ staticElement: ConstructorMember
+ base: self::@enum::E::@constructor::•
+ substitution: {T: String}
+ staticType: null
+ token: @-1
+ period: . @0
+ staticElement: ConstructorMember
+ base: self::@enum::E::@constructor::•
+ substitution: {T: String}
+ type: NamedType
+ name: SimpleIdentifier
+ staticElement: self::@enum::E
+ staticType: null
+ token: E @-1
+ type: E<String>
+ staticType: E<String>
+ synthetic static const values @-1
+ type: List<E<dynamic>>
+ constantInitializer
+ ListLiteral
+ elements
+ SimpleIdentifier
+ staticElement: self::@enum::E::@getter::int
+ staticType: E<int>
+ token: int @-1
+ SimpleIdentifier
+ staticElement: self::@enum::E::@getter::string
+ staticType: E<String>
+ token: string @-1
+ leftBracket: [ @0
+ rightBracket: ] @0
+ staticType: List<E<dynamic>>
synthetic final index @-1
type: int
- static const enumConstant v @69
+ synthetic final _name @-1
+ type: String
+ constructors
+ @37
+ parameters
+ requiredPositional final this.index @-1
+ type: int
+ field: self::@enum::E::@field::index
+ requiredPositional final this._name @-1
+ type: String
+ field: self::@enum::E::@field::_name
+ requiredPositional a @41
+ type: T
+ accessors
+ synthetic static get int @-1
+ returnType: E<int>
+ synthetic static get string @-1
+ returnType: E<String>
+ synthetic static get values @-1
+ returnType: List<E<dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
+ methods
+ synthetic toString @-1
+ returnType: String
+''');
+ }
+
+ /// Test that a constant named `_name` renames the synthetic `name` field.
+ test_enum_constant_name() async {
+ var library = await checkLibrary(r'''
+enum E {
+ _name;
+}
+''');
+ checkElementText(library, r'''
+library
+ definingUnit
+ enums
+ enum E @5
+ supertype: Enum
+ fields
+ static const enumConstant _name @11
+ type: E
+ constantInitializer
+ InstanceCreationExpression
+ argumentList: ArgumentList
+ arguments
+ IntegerLiteral
+ literal: 0 @0
+ staticType: int
+ SimpleStringLiteral
+ literal: '_name' @0
+ leftParenthesis: ( @0
+ rightParenthesis: ) @0
+ constructorName: ConstructorName
+ name: SimpleIdentifier
+ staticElement: self::@enum::E::@constructor::•
+ staticType: null
+ token: @-1
+ period: . @0
+ staticElement: self::@enum::E::@constructor::•
+ type: NamedType
+ name: SimpleIdentifier
+ staticElement: self::@enum::E
+ staticType: null
+ token: E @-1
+ type: E
+ staticType: E
+ synthetic static const values @-1
+ type: List<E>
+ constantInitializer
+ ListLiteral
+ elements
+ SimpleIdentifier
+ staticElement: self::@enum::E::@getter::_name
+ staticType: E
+ token: _name @-1
+ leftBracket: [ @0
+ rightBracket: ] @0
+ staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name2 @-1
+ type: String
+ constructors
+ synthetic const @-1
+ parameters
+ requiredPositional final this.index @-1
+ type: int
+ field: self::@enum::E::@field::index
+ requiredPositional final this._name2 @-1
+ type: String
+ field: self::@enum::E::@field::_name2
+ accessors
+ synthetic static get _name @-1
+ returnType: E
+ synthetic static get values @-1
+ returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name2 @-1
+ returnType: String
+ methods
+ synthetic toString @-1
+ returnType: String
+''');
+ }
+
+ test_enum_constant_underscore() async {
+ var library = await checkLibrary('''
+enum E {
+ _
+}
+''');
+ checkElementText(library, r'''
+library
+ definingUnit
+ enums
+ enum E @5
+ supertype: Enum
+ fields
+ static const enumConstant _ @11
+ type: E
+ constantInitializer
+ InstanceCreationExpression
+ argumentList: ArgumentList
+ arguments
+ IntegerLiteral
+ literal: 0 @0
+ staticType: int
+ SimpleStringLiteral
+ literal: '_' @0
+ leftParenthesis: ( @0
+ rightParenthesis: ) @0
+ constructorName: ConstructorName
+ name: SimpleIdentifier
+ staticElement: self::@enum::E::@constructor::•
+ staticType: null
+ token: @-1
+ period: . @0
+ staticElement: self::@enum::E::@constructor::•
+ type: NamedType
+ name: SimpleIdentifier
+ staticElement: self::@enum::E
+ staticType: null
+ token: E @-1
+ type: E
+ staticType: E
+ synthetic static const values @-1
+ type: List<E>
+ constantInitializer
+ ListLiteral
+ elements
+ SimpleIdentifier
+ staticElement: self::@enum::E::@getter::_
+ staticType: E
+ token: _ @-1
+ leftBracket: [ @0
+ rightBracket: ] @0
+ staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
+ constructors
+ synthetic const @-1
+ parameters
+ requiredPositional final this.index @-1
+ type: int
+ field: self::@enum::E::@field::index
+ requiredPositional final this._name @-1
+ type: String
+ field: self::@enum::E::@field::_name
+ accessors
+ synthetic static get _ @-1
+ returnType: E
+ synthetic static get values @-1
+ returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
+ methods
+ synthetic toString @-1
+ returnType: String
+''');
+ }
+
+ test_enum_constructor_named() async {
+ var library = await checkLibrary(r'''
+enum E {
+ v.named(42);
+ E.named(int a);
+}
+''');
+ checkElementText(library, r'''
+library
+ definingUnit
+ enums
+ enum E @5
+ supertype: Enum
+ fields
+ static const enumConstant v @11
type: E
constantInitializer
InstanceCreationExpression
@@ -17533,15 +17853,18 @@
staticType: int
SimpleStringLiteral
literal: 'v' @0
+ IntegerLiteral
+ literal: 42 @19
+ staticType: int
leftParenthesis: ( @0
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::named
staticType: null
- token: _ @-1
+ token: named @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::named
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -17561,21 +17884,200 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ named @28
+ periodOffset: 27
+ nameEnd: 33
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
+ requiredPositional a @38
+ type: int
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
+ methods
+ synthetic toString @-1
+ returnType: String
+''');
+ }
+
+ test_enum_constructor_unnamed() async {
+ var library = await checkLibrary(r'''
+enum E {
+ v(42);
+ E(int a);
+}
+''');
+ checkElementText(library, r'''
+library
+ definingUnit
+ enums
+ enum E @5
+ supertype: Enum
+ fields
+ static const enumConstant v @11
+ type: E
+ constantInitializer
+ InstanceCreationExpression
+ argumentList: ArgumentList
+ arguments
+ IntegerLiteral
+ literal: 0 @0
+ staticType: int
+ SimpleStringLiteral
+ literal: 'v' @0
+ IntegerLiteral
+ literal: 42 @13
+ staticType: int
+ leftParenthesis: ( @0
+ rightParenthesis: ) @0
+ constructorName: ConstructorName
+ name: SimpleIdentifier
+ staticElement: self::@enum::E::@constructor::•
+ staticType: null
+ token: @-1
+ period: . @0
+ staticElement: self::@enum::E::@constructor::•
+ type: NamedType
+ name: SimpleIdentifier
+ staticElement: self::@enum::E
+ staticType: null
+ token: E @-1
+ type: E
+ staticType: E
+ synthetic static const values @-1
+ type: List<E>
+ constantInitializer
+ ListLiteral
+ elements
+ SimpleIdentifier
+ staticElement: self::@enum::E::@getter::v
+ staticType: E
+ token: v @-1
+ leftBracket: [ @0
+ rightBracket: ] @0
+ staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
+ constructors
+ @20
+ parameters
+ requiredPositional final this.index @-1
+ type: int
+ field: self::@enum::E::@field::index
+ requiredPositional final this._name @-1
+ type: String
+ field: self::@enum::E::@field::_name
+ requiredPositional a @26
+ type: int
+ accessors
+ synthetic static get v @-1
+ returnType: E
+ synthetic static get values @-1
+ returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
+ methods
+ synthetic toString @-1
+ returnType: String
+''');
+ }
+
+ test_enum_documented() async {
+ var library = await checkLibrary('''
+// Extra comment so doc comment offset != 0
+/**
+ * Docs
+ */
+enum E { v }''');
+ checkElementText(library, r'''
+library
+ definingUnit
+ enums
+ enum E @65
+ documentationComment: /**\n * Docs\n */
+ supertype: Enum
+ fields
+ static const enumConstant v @69
+ type: E
+ constantInitializer
+ InstanceCreationExpression
+ argumentList: ArgumentList
+ arguments
+ IntegerLiteral
+ literal: 0 @0
+ staticType: int
+ SimpleStringLiteral
+ literal: 'v' @0
+ leftParenthesis: ( @0
+ rightParenthesis: ) @0
+ constructorName: ConstructorName
+ name: SimpleIdentifier
+ staticElement: self::@enum::E::@constructor::•
+ staticType: null
+ token: @-1
+ period: . @0
+ staticElement: self::@enum::E::@constructor::•
+ type: NamedType
+ name: SimpleIdentifier
+ staticElement: self::@enum::E
+ staticType: null
+ token: E @-1
+ type: E
+ staticType: E
+ synthetic static const values @-1
+ type: List<E>
+ constantInitializer
+ ListLiteral
+ elements
+ SimpleIdentifier
+ staticElement: self::@enum::E::@getter::v
+ staticType: E
+ token: v @-1
+ leftBracket: [ @0
+ rightBracket: ] @0
+ staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
+ constructors
+ synthetic const @-1
+ parameters
+ requiredPositional final this.index @-1
+ type: int
+ field: self::@enum::E::@field::index
+ requiredPositional final this._name @-1
+ type: String
+ field: self::@enum::E::@field::_name
+ accessors
+ synthetic static get v @-1
+ returnType: E
+ synthetic static get values @-1
+ returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -17596,8 +18098,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @11
type: E
constantInitializer
@@ -17613,11 +18113,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -17637,6 +18137,10 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
final foo @22
type: int
constantInitializer
@@ -17644,20 +18148,23 @@
literal: 42 @28
staticType: int
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
synthetic get foo @-1
returnType: int
methods
@@ -17683,8 +18190,6 @@
defaultType: dynamic
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @14
type: E<dynamic>
constantInitializer
@@ -17701,13 +18206,13 @@
constructorName: ConstructorName
name: SimpleIdentifier
staticElement: ConstructorMember
- base: self::@enum::E::@constructor::_
+ base: self::@enum::E::@constructor::•
substitution: {T: dynamic}
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
staticElement: ConstructorMember
- base: self::@enum::E::@constructor::_
+ base: self::@enum::E::@constructor::•
substitution: {T: dynamic}
type: NamedType
name: SimpleIdentifier
@@ -17728,21 +18233,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<dynamic>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E<dynamic>
synthetic static get values @-1
returnType: List<E<dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
foo @23
typeParameters
@@ -17772,8 +18284,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @11
type: E
constantInitializer
@@ -17789,11 +18299,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -17813,21 +18323,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
toString @23
returnType: String
@@ -17850,8 +18367,6 @@
defaultType: dynamic
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @14
type: E<dynamic>
constantInitializer
@@ -17868,13 +18383,13 @@
constructorName: ConstructorName
name: SimpleIdentifier
staticElement: ConstructorMember
- base: self::@enum::E::@constructor::_
+ base: self::@enum::E::@constructor::•
substitution: {T: dynamic}
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
staticElement: ConstructorMember
- base: self::@enum::E::@constructor::_
+ base: self::@enum::E::@constructor::•
substitution: {T: dynamic}
type: NamedType
name: SimpleIdentifier
@@ -17895,21 +18410,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<dynamic>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E<dynamic>
synthetic static get values @-1
returnType: List<E<dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -17936,8 +18458,6 @@
defaultType: num
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @39
type: E<num, num>
constantInitializer
@@ -17954,13 +18474,13 @@
constructorName: ConstructorName
name: SimpleIdentifier
staticElement: ConstructorMember
- base: self::@enum::E::@constructor::_
+ base: self::@enum::E::@constructor::•
substitution: {T: num, U: num}
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
staticElement: ConstructorMember
- base: self::@enum::E::@constructor::_
+ base: self::@enum::E::@constructor::•
substitution: {T: num, U: num}
type: NamedType
name: SimpleIdentifier
@@ -17981,21 +18501,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<num, num>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E<num, num>
synthetic static get values @-1
returnType: List<E<num, num>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18017,8 +18544,6 @@
defaultType: dynamic
supertype: Enum
fields
- synthetic final index @-1
- type: int
synthetic static const values @-1
type: List<E<dynamic>>
constantInitializer
@@ -18026,19 +18551,26 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<dynamic>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get values @-1
returnType: List<E<dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18066,8 +18598,6 @@
defaultType: dynamic
supertype: Enum
fields
- synthetic final index @-1
- type: int
synthetic static const values @-1
type: List<E<dynamic, num, dynamic>>
constantInitializer
@@ -18075,19 +18605,26 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<dynamic, num, dynamic>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get values @-1
returnType: List<E<dynamic, num, dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18109,8 +18646,6 @@
defaultType: dynamic
supertype: Enum
fields
- synthetic final index @-1
- type: int
synthetic static const values @-1
type: List<E<dynamic>>
constantInitializer
@@ -18118,19 +18653,26 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<dynamic>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get values @-1
returnType: List<E<dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18151,8 +18693,6 @@
defaultType: dynamic
supertype: Enum
fields
- synthetic final index @-1
- type: int
synthetic static const values @-1
type: List<E<dynamic>>
constantInitializer
@@ -18160,19 +18700,26 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<dynamic>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get values @-1
returnType: List<E<dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18193,8 +18740,6 @@
defaultType: dynamic
supertype: Enum
fields
- synthetic final index @-1
- type: int
synthetic static const values @-1
type: List<E<dynamic>>
constantInitializer
@@ -18202,19 +18747,26 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<dynamic>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get values @-1
returnType: List<E<dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18235,8 +18787,6 @@
defaultType: dynamic
supertype: Enum
fields
- synthetic final index @-1
- type: int
synthetic static const values @-1
type: List<E<dynamic>>
constantInitializer
@@ -18244,19 +18794,26 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<dynamic>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get values @-1
returnType: List<E<dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18281,8 +18838,6 @@
defaultType: dynamic
supertype: Enum
fields
- synthetic final index @-1
- type: int
synthetic static const values @-1
type: List<E<dynamic, dynamic, dynamic>>
constantInitializer
@@ -18290,19 +18845,26 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<dynamic, dynamic, dynamic>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get values @-1
returnType: List<E<dynamic, dynamic, dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18326,8 +18888,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant a @32
documentationComment: /**\n * aaa\n */
type: E
@@ -18344,11 +18904,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -18372,11 +18932,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -18400,23 +18960,30 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get a @-1
returnType: E
synthetic static get b @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18445,8 +19012,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant a @46
documentationComment: /**\n * aaa\n */
metadata
@@ -18471,11 +19036,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -18507,11 +19072,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -18535,23 +19100,30 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get a @-1
returnType: E
synthetic static get b @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18568,81 +19140,6 @@
''');
}
- test_enum_value_underscore() async {
- var library = await checkLibrary('''
-enum E {
- _
-}
-''');
- checkElementText(library, r'''
-library
- definingUnit
- enums
- enum E @5
- supertype: Enum
- fields
- synthetic final index @-1
- type: int
- static const enumConstant _ @11
- type: E
- constantInitializer
- InstanceCreationExpression
- argumentList: ArgumentList
- arguments
- IntegerLiteral
- literal: 0 @0
- staticType: int
- SimpleStringLiteral
- literal: '_' @0
- leftParenthesis: ( @0
- rightParenthesis: ) @0
- constructorName: ConstructorName
- name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_1
- staticType: null
- token: _1 @-1
- period: . @0
- staticElement: self::@enum::E::@constructor::_1
- type: NamedType
- name: SimpleIdentifier
- staticElement: self::@enum::E
- staticType: null
- token: E @-1
- type: E
- staticType: E
- synthetic static const values @-1
- type: List<E>
- constantInitializer
- ListLiteral
- elements
- SimpleIdentifier
- staticElement: self::@enum::E::@getter::_
- staticType: E
- token: _ @-1
- leftBracket: [ @0
- rightBracket: ] @0
- staticType: List<E>
- constructors
- synthetic const _1 @-1
- parameters
- requiredPositional final this.index @-1
- type: int
- field: self::@enum::E::@field::index
- requiredPositional name @-1
- type: String
- accessors
- synthetic get index @-1
- returnType: int
- synthetic static get _ @-1
- returnType: E
- synthetic static get values @-1
- returnType: List<E>
- methods
- synthetic toString @-1
- returnType: String
-''');
- }
-
test_enum_values() async {
var library = await checkLibrary('enum E { v1, v2 }');
checkElementText(library, r'''
@@ -18652,8 +19149,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v1 @9
type: E
constantInitializer
@@ -18669,11 +19164,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -18696,11 +19191,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -18724,23 +19219,30 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v1 @-1
returnType: E
synthetic static get v2 @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18756,8 +19258,6 @@
enum E1 @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v1 @10
type: E1
constantInitializer
@@ -18773,11 +19273,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E1::@constructor::_
+ staticElement: self::@enum::E1::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E1::@constructor::_
+ staticElement: self::@enum::E1::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E1
@@ -18797,29 +19297,34 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E1>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E1::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E1::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v1 @-1
returnType: E1
synthetic static get values @-1
returnType: List<E1>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
enum E2 @20
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v2 @25
type: E2
constantInitializer
@@ -18835,11 +19340,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E2::@constructor::_
+ staticElement: self::@enum::E2::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E2::@constructor::_
+ staticElement: self::@enum::E2::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E2
@@ -18859,21 +19364,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E2>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E2::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E2::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v2 @-1
returnType: E2
synthetic static get values @-1
returnType: List<E2>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -18947,8 +19459,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant a @8
type: E
constantInitializer
@@ -18964,11 +19474,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -18991,11 +19501,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -19018,11 +19528,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -19050,17 +19560,20 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get a @-1
returnType: E
synthetic static get b @-1
@@ -19069,6 +19582,10 @@
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -25907,8 +26424,6 @@
enum E @19
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @26
metadata
Annotation
@@ -25932,11 +26447,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -25956,21 +26471,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -26021,8 +26543,6 @@
enum E @64
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant a @78
metadata
Annotation
@@ -26053,11 +26573,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -26080,11 +26600,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -26122,11 +26642,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -26154,17 +26674,20 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get a @-1
returnType: E
synthetic static get b @-1
@@ -26173,6 +26696,10 @@
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -26196,8 +26723,6 @@
token: a @15
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @26
type: E
constantInitializer
@@ -26213,11 +26738,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -26237,21 +26762,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -27738,8 +28270,6 @@
token: foo @17
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant e1 @37
metadata
Annotation
@@ -27763,11 +28293,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -27790,11 +28320,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -27825,11 +28355,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -27857,17 +28387,20 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get e1 @-1
returnType: E
synthetic static get e2 @-1
@@ -27876,6 +28409,10 @@
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -28917,8 +29454,6 @@
token: a @22
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @31
type: E<dynamic>
constantInitializer
@@ -28935,13 +29470,13 @@
constructorName: ConstructorName
name: SimpleIdentifier
staticElement: ConstructorMember
- base: self::@enum::E::@constructor::_
+ base: self::@enum::E::@constructor::•
substitution: {T: dynamic}
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
staticElement: ConstructorMember
- base: self::@enum::E::@constructor::_
+ base: self::@enum::E::@constructor::•
substitution: {T: dynamic}
type: NamedType
name: SimpleIdentifier
@@ -28962,21 +29497,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E<dynamic>>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E<dynamic>
synthetic static get values @-1
returnType: List<E<dynamic>>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -29184,8 +29726,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant a @8
type: E
constantInitializer
@@ -29201,11 +29741,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -29228,11 +29768,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -29255,11 +29795,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -29287,17 +29827,20 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get a @-1
returnType: E
synthetic static get b @-1
@@ -29306,6 +29849,10 @@
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -30596,9 +31143,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
- nonSynthetic: self::@enum::E
static const enumConstant a @11
type: E
constantInitializer
@@ -30614,11 +31158,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -30642,11 +31186,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -30672,21 +31216,25 @@
rightBracket: ] @0
staticType: List<E>
nonSynthetic: self::@enum::E
+ synthetic final index @-1
+ type: int
+ nonSynthetic: self::@enum::E
+ synthetic final _name @-1
+ type: String
+ nonSynthetic: self::@enum::E::@getter::_name
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
nonSynthetic: index@-1
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
- nonSynthetic: name@-1
+ nonSynthetic: _name@-1
+ field: self::@enum::E::@field::_name
nonSynthetic: self::@enum::E
accessors
- synthetic get index @-1
- returnType: int
- nonSynthetic: self::@enum::E
synthetic static get a @-1
returnType: E
nonSynthetic: self::@enum::E::@field::a
@@ -30696,6 +31244,12 @@
synthetic static get values @-1
returnType: List<E>
nonSynthetic: self::@enum::E
+ synthetic get index @-1
+ returnType: int
+ nonSynthetic: self::@enum::E
+ synthetic get _name @-1
+ returnType: String
+ nonSynthetic: self::@enum::E::@field::_name
methods
synthetic toString @-1
returnType: String
@@ -32672,8 +33226,6 @@
enum E @16
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @20
type: E
constantInitializer
@@ -32689,11 +33241,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -32713,21 +33265,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -32822,8 +33381,6 @@
enum E @27
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @31
type: E
constantInitializer
@@ -32839,11 +33396,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -32863,21 +33420,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -32906,8 +33470,6 @@
enum E @42
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @46
type: E
constantInitializer
@@ -32923,11 +33485,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -32947,21 +33509,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -33027,8 +33596,6 @@
enum E @27
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @31
type: E
constantInitializer
@@ -33044,11 +33611,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -33068,21 +33635,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -33146,8 +33720,6 @@
enum E @27
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @31
type: E
constantInitializer
@@ -33163,11 +33735,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -33187,21 +33759,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
@@ -33333,8 +33912,6 @@
enum E @5
supertype: Enum
fields
- synthetic final index @-1
- type: int
static const enumConstant v @9
type: E
constantInitializer
@@ -33350,11 +33927,11 @@
rightParenthesis: ) @0
constructorName: ConstructorName
name: SimpleIdentifier
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
staticType: null
- token: _ @-1
+ token: @-1
period: . @0
- staticElement: self::@enum::E::@constructor::_
+ staticElement: self::@enum::E::@constructor::•
type: NamedType
name: SimpleIdentifier
staticElement: self::@enum::E
@@ -33374,21 +33951,28 @@
leftBracket: [ @0
rightBracket: ] @0
staticType: List<E>
+ synthetic final index @-1
+ type: int
+ synthetic final _name @-1
+ type: String
constructors
- synthetic const _ @-1
+ synthetic const @-1
parameters
requiredPositional final this.index @-1
type: int
field: self::@enum::E::@field::index
- requiredPositional name @-1
+ requiredPositional final this._name @-1
type: String
+ field: self::@enum::E::@field::_name
accessors
- synthetic get index @-1
- returnType: int
synthetic static get v @-1
returnType: E
synthetic static get values @-1
returnType: List<E>
+ synthetic get index @-1
+ returnType: int
+ synthetic get _name @-1
+ returnType: String
methods
synthetic toString @-1
returnType: String
diff --git a/pkg/dev_compiler/doc/GENERIC_METHODS.md b/pkg/dev_compiler/doc/GENERIC_METHODS.md
deleted file mode 100644
index f57d127..0000000
--- a/pkg/dev_compiler/doc/GENERIC_METHODS.md
+++ /dev/null
@@ -1,191 +0,0 @@
-# Using Generic Methods
-
-**Note: This document is out of date. Please see [Sound Dart](https://dart.dev/guides/language/sound-dart) for up-to-date
-documentation on Dart's type system. The work below was a precursor towards Dart's current type system.
-
-For historical reasons, this feature is called "generic methods", but it
-applies equally well to instance methods, static methods, top-level functions,
-local functions, and even lambda expressions.**
-
-Initially a [proposal][], generic methods are on their way to being fully
-supported in Dart. Here is how to use them.
-
-[proposal]: https://github.com/leafpetersen/dep-generic-methods/blob/master/proposal.md
-
-When they were still being prototyped, an [older comment-based syntax was
-designed][old] so that the static analysis could be implemented and tested
-before the VM and compilers needed to worry about the syntax. Now that real
-syntax is allowed everywhere, this doc has been updated.
-
-[old]: GENERIC_METHOD_COMMENTS.md
-
-## Declaring generic methods
-
-Type parameters for generic methods are listed after the method or function
-name, inside angle brackets:
-
-```dart
-/// Takes two type parameters, [K] and [V].
-Map<K, V> singletonMap<K, V>(K key, V value) {
- return <K, V>{ key, value };
-}
-```
-
-As with classes, you can put bounds on type parameters:
-
-```dart
-/// Takes a list of two numbers of some num-derived type [T].
-T sumPair<T extends num>(List<T> items) {
- return items[0] + items[1];
-}
-```
-
-Class methods (instance and static) can be declared to take generic parameters
-in the same way:
-
-```dart
-class C {
- static int f<S, T>(int x) => 3;
- int m<S, T>(int x) => 3;
-}
-```
-
-This even works for function-typed parameters, local functions, and function
-expressions:
-
-```dart
-/// Takes a generic method as a parameter [callback].
-void functionTypedParameter(T callback<T>(T thing)) {}
-
-// Declares a local generic function `itself`.
-void localFunction() {
- T itself<T>(T thing) => thing;
-}
-
-// Binds a generic function expression to a local variable.
-void functionExpression() {
- var lambda = <T>(T thing) => thing;
-}
-```
-
-We do not currently support a way to declare a function as *returning* a generic
-function. This will eventually be supported using a `typedef`.
-
-## Using generic method type parameters
-
-You've seen some examples already, but you can use a generic type parameter
-almost anywhere you would expect in a generic method.
-
-* Inside the method's parameter list:
-
- ```dart
- takeThing<T>(T thing) { ... }
- // ^-- Here.
- ```
-
-* Inside type annotations in the body of the method:
-
- ```dart
- useThing<T>() {
- T thing = getThing();
- //^-- Here.
- List<T> pair = [thing, thing];
- // ^-- And here.
- }
- ```
-
-* In the return type of the method:
-
- ```dart
- T itself<T>(T thing) => thing;
- //^-- Here.
- ```
-
-* As type arguments in generic classes and method calls:
-
- ```dart
- useThing<T>(T thing) {
- var pair = <T>[thing, thing];
- // ^-- Here.
- var set = new Set<T>()..add(thing);
- // ^-- And here.
- }
- ```
-
- Note that generic methods are not yet supported *at runtime* on the VM and
- dart2js. On those platforms, uses of generic method type arguments are
- treated like `dynamic` today. So in this example, `pair`'s reified type at
- runtime will be `List<dynamic>` and `set` will be `Set<dynamic>`.
-
-There are two places you *cannot* use a generic method type parameter. Both are
-because the VM and dart2js don't support reifying generic method type arguments
-yet. Since these expressions wouldn't do what you want, we've temporarily
-defined them to be an error:
-
-* As the right-hand side of an `is` or `is!` expression.
-
- ```dart
- testType<T>(object) {
- print(object is T);
- // ^-- Error!
- print(object is! T);
- // ^-- Error!
- }
- ```
-
-* As a type literal:
-
- ```dart
- printType<T>() {
- Type t = T;
- // ^-- Error!
- print(t);
- }
- ```
-
-Once we have full runtime support for generic methods, these will be allowed.
-
-## Calling generic methods
-
-Most of the time, when you call a generic method, you can leave off the type
-arguments and strong mode's type inference will fill them in for you
-automatically. For example:
-
-```dart
-var fruits = ["apple", "banana", "cherry"];
-var lengths = fruits.map((fruit) => fruit.length);
-```
-
-The `map()` method on Iterable is now generic and takes a type parameter for the
-element type of the returned sequence:
-
-```dart
-class Iterable<T> {
- Iterable<S> map<S>(S transform(T element)) { ... }
-
- // Other stuff...
-}
-```
-
-In this example, the type checker:
-
-1. Infers `List<String>` for the type of `fruits` based on the elements in the
- list literal.
-2. That lets it infer `String` for the type of the lambda parameter `fruit`
- passed to `map()`.
-3. Then, from the result of calling `.length`, it infers the return type of the
- lambda to be `int`.
-4. That in turn is used to fill in the type argument to the call to `map()` as
- `int`, and the resulting sequence is an `Iterable<int>`.
-
-If inference *isn't* able to fill in a type argument for you, it uses `dynamic`
-instead. If that isn't what you want, or it infers a type you don't want, you
-can always pass them explicitly:
-
-```dart
-// Explicitly give a type so that we don't infer "int".
-var lengths = fruits.map<num>((fruit) => fruit.length).toList();
-
-// So that we can later add doubles to the result.
-lengths.add(1.2);
-```
diff --git a/pkg/dev_compiler/doc/GENERIC_METHOD_COMMENTS.md b/pkg/dev_compiler/doc/GENERIC_METHOD_COMMENTS.md
deleted file mode 100644
index 9050eab..0000000
--- a/pkg/dev_compiler/doc/GENERIC_METHOD_COMMENTS.md
+++ /dev/null
@@ -1,237 +0,0 @@
-# Prototype Syntax for Generic Methods
-
-**Note:** This documents the deprecated comment-based syntax for generic
-methods. New code should use the [much better real syntax][real]. This document
-is preserved in case you run into existing code still using the old syntax.
-
-[real]: GENERIC_METHODS.md
-
----
-
-Generic methods are a [proposed addition to the Dart language](https://github.com/leafpetersen/dep-generic-methods/blob/master/proposal.md).
-
-This is a summary of the current (as of January 2016) comment-based generic
-method syntax supported by the analyzer strong mode and the Dart Dev Compiler.
-The comment-based syntax essentially uses the proposed actual generic method
-syntax, but wraps it in comments. This allows developers to experiment with
-generic methods while still ensuring that their code runs on all platforms while
-generic methods are still being evaluated for inclusion into the language.
-
-## Declaring generic method parameters
-
-Generic method parameters are listed using a block comment after the method or
-function name, inside of angle brackets.
-
-```dart
-// This declares a function which takes two unused generic method parameters
-int f/*<S, T>*/(int x) => 3;
-```
-
-As with classes, you can put bounds on type parameters.
-
-```dart
-// This declares a function which takes two unused generic method parameters
-// The first parameter (S) must extend num
-// The second parameter (T) must extend List<S>
-int f/*<S extends num, T extends List<S>>*/(int x) => 3;
-```
-
-Class methods (instance and static) can be declared to take generic parameters
-in the same way.
-
-```dart
-class C {
- static int f/*<S, T>*/(int x) => 3;
- int m/*<S, T>*/(int x) => 3;
-}
-```
-
-Function typed parameters, local functions, and function expressions can also be
-declared to take generic parameters.
-
-```dart
-// foo takes a generic method as a parameter
-void foo(int f/*<S>*/(int x)) {}
-
-// foo declares a local generic function
-void foo() {
- int f/*<S>*/(int x) => 3;
- return;
-}
-
-// foo binds a generic function expression to a local variable.
-void foo() {
- var x = /*<S>*/(int x) => x;
-}
-```
-
-We do not currently support a way to declare a function as returning a generic
-function. This will eventually be supported using something analogous to Dart
-typedefs.
-
-## Using generic method parameters
-
-The previous examples declared generic method parameters, but did not use them.
-You can use a generic method parameter `T` anywhere that a type is expected in
-Dart by writing a type followed by `/*=T*/`. So for example, `dynamic /*=T*/`
-will be interpreted as `dynamic` by all non-strong mode tools, but will be
-interpreted as `T` by strong mode. In places where it is valid to leave off a
-type, simply writing `/*=T*/` will be interpreted as `dynamic` by non-strong
-mode tools, but will be interpreted as `T` by strong mode. For example:
-
-```dart
-// foo is a generic method which takes a single generic method parameter S.
-// In strong mode, the parameter x will have type S, and the return type will
-// be S
-// In normal mode, the parameter x will have type dynamic, and the return
-// type will be dynamic.
-dynamic/*=S*/ foo/*<S>*/(dynamic/*=S*/ x) { return x; }
-```
-
-This can be written more concisely by leaving off the `dynamic`.
-
-```dart
-/*=S*/ foo/*<S>*/(/*=S*/ x) {return x;}
-```
-
-You can also put a type to the left of the `/*=T/`. This type will be used
-for all non-strong mode tools. For example:
-
-```dart
-// This method works with `int`, `double`, or `num`. The return type will
-// match the type of the parameters.
-num/*=T*/ pickAtRandom/*<T extends num>*/(num/*=T*/ x, num/*=T*/ y) { ... }
-```
-
-
-Note that the generic parameter is in scope in the return type of the function,
-in the argument list of the function, and in the body of the function. When
-declaring local variables and parameters, you can also use the `/*=T*/` syntax with `var`.
-
-```dart
-// foo is a generic method that takes a single generic parameter S, and a value
-// x of type S
-void foo/*<S>*/(var /*=S*/ x) {
- // In strong mode, y will also have type S
- var /*=S*/ y = x;
-
- // In strong mode, z will also have type S
- dynamic /*=S*/ z = y;
-}
-```
-
-Anywhere that a type literal is expected, you can also use the `/*=T*/` syntax to
-produce a type literal from the generic method parameter.
-
-```dart
-void foo/*<S>*/(/*=S*/ x) {
- // In strong mode, s will get the type literal for S
- Type s = dynamic /*=S*/;
-
- // In strong mode, this attempts to cast 3 as type S
- var y = (3 as dynamic /*=S*/);
-}
-```
-
-You can use the `/*=T*/` syntax to replace any type with a generic type
-parameter, but you will usually want to replace `dynamic`. Otherwise, since the
-original type is used at runtime, it may cause checked mode errors:
-
-```dart
-List/*<T>*/ makeList/*<T extends num>*/() {
- return new List<num /*=T*/>();
-}
-
-void main() {
- List<int> list = makeList/*<int>*/(); // <-- Fails here.
-}
-```
-
-This program checks without error in strong mode but fails at runtime in checked
-mode since the list that gets created is a `List<num>`. A better choice is:
-
-```dart
-List/*<T>*/ makeList/*<T extends num>*/() {
- return new List/*<T>*/();
-}
-
-void main() {
- List<int> list = makeList/*<int>*/();
-}
-```
-
-## Instantiating generic classes with generic method parameters
-
-You can use generic method parameters to instantiate generic classes using the
-same `/*=T*/` syntax.
-
-```dart
-// foo is a generic method which returns a List<S> in strong mode,
-// but which returns List<dynamic> in normal mode.
-List<dynamic /*=S*/> foo/*<S>*/(/*=S*/ x) {
- // l0 is a list literal whose reified type will be List<S> in strong mode,
- // and List<dynamic> in normal mode.
- var l0 = <dynamic /*=S*/>[x];
-
- // as above, but with a regular constructor.
- var l1 = new List<dynamic /*=S*/>();
- return l1;
-}
-```
-
-In most cases, the entire type argument list to the generic class can be
-enclosed in parentheses, eliminating the need for explicitly writing `dynamic`.
-
-```dart
-// This is another way of writing the same code as above
-List/*<S>*/ foo/*<S>*/(/*=S*/ x) {
- // The shorthand syntax is not yet supported for list and map literals
- var l0 = <dynamic /*=S*/>[x];
-
- // but with regular constructors you can use it
- var l1 = new List/*<S>*/();
- return l1;
-}
-```
-
-## Instantiating generic methods
-
-Generic methods can be called without passing type arguments. Strong mode will
-attempt to infer the type arguments automatically. If it is unable to do so,
-then the type arguments will be filled in with whatever their declared bounds
-are (by default, `dynamic`).
-
-```dart
-class C {
- /*=S*/ inferableFromArgument/*<S>*/(/*=S*/ x) { return null;}
- /*=S*/ notInferable/*<S>*/(int x) { return null;}
-}
-
-void main() {
- C c = new C();
- // This line will produce a type error, because strong mode will infer
- // `int` as the generic argument to fill in for S
- String x = c.inferableFromArgument(3);
-
- // This line will not produce a type error, because strong mode is unable
- // to infer a type and will fill in the type argument with `dynamic`.
- String y = c.notInferable(3);
-}
-```
-
-In the case that strong mode cannot infer the generic type arguments, the same
-syntax that was shown above for instantiating generic classes can be used to
-instantiate generic methods explicitly.
-
-```dart
-void main() {
- C c = new C();
- // This line will produce a type error, because strong mode will infer
- // `int` as the generic argument to fill in for S
- String x = c.inferableFromArgument(3);
-
- // This line will produce a type error in strong mode, because `int` is
- // explicitly passed in as the argument to use for S
- String y = c.notInferable/*<int>*/(3);
-}
-```
diff --git a/pkg/dev_compiler/doc/JS_CODEGEN.md b/pkg/dev_compiler/doc/JS_CODEGEN.md
deleted file mode 100644
index 11b9b8f..0000000
--- a/pkg/dev_compiler/doc/JS_CODEGEN.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# Strong Mode and Idiomatic JavaScript
-
-**Note: This document is out of date. Please see [Sound Dart](https://dart.dev/guides/language/sound-dart) for up-to-date
-documentation on Dart's type system. The work below was a precursor towards Dart's current type system.**
-
-The Dart Dev Compiler (DDC) uses [Strong Mode](STRONG_MODE.md) to safely generate
-idiomatic JavaScript. This enables better interoperability between Dart and JavaScript code.
-
-The standard Dart type system is unsound by design. This means that static type annotations may not match the actual runtime values even when a program is running in checked mode. This allows considerable flexibility, but it also means that Dart implementations cannot easily use these annotations for optimization or code generation.
-
-Because of this, existing Dart implementations require dynamic dispatch. Furthermore, because Dart’s dispatch semantics are different from JavaScript’s, it effectively precludes mapping Dart calls to idiomatic JavaScript. For example, the following Dart code:
-
-```dart
-var x = a.bar;
-b.foo("hello", x);
-```
-
-cannot easily be mapped to the identical JavaScript code. If `a` does not contain a `bar` field, Dart requires a `NoSuchMethodError` while JavaScript simply returns undefined. If `b` contains a `foo` method, but with the wrong number of arguments, Dart again requires a `NoSuchMethodError` while JavaScript either ignores extra arguments or fills in omitted ones with undefined.
-
-To capture these differences, the Dart2JS compiler instead generates code that approximately looks like:
-
-```dart
-var x = getInterceptor(a).get$bar(a);
-getInterceptor(b).foo$2(b, "hello", x);
-```
-The “interceptor” is Dart’s dispatch table for the objects `a` and `b`, and the mangled names (`get$bar` and `foo$2`) account for Dart’s different dispatch semantics.
-
-The above highlights why Dart-JavaScript interoperability hasn’t been seamless: Dart objects and methods do not look like normal JavaScript ones.
-
-DDC relies on strong mode to map Dart calling conventions to normal JavaScript ones. If `a` and `b` have static type annotations (with a type other than `dynamic`), strong mode statically verifies that they have a field `bar` and a 2-argument method `foo` respectively. In this case, DDC safely generates the identical JavaScript:
-
-```javascript
-var x = a.bar;
-b.foo("hello", x);
-```
-
-Note that DDC still supports the `dynamic` type, but relies on runtime helper functions in this case. E.g., if `a` and `b` are type `dynamic`, DDC instead generates:
-
-```javascript
-var x = dload(a, "bar");
-dsend(b, "foo", "hello", x);
-```
-
-where `dload` and `dsend` are runtime helpers that implement Dart dispatch semantics. Programmers are encouraged to use static annotations to avoid this. Strong mode is able to use static checking to enforce much of what checked mode does at runtime. In the code above, strong mode statically verifies that `b`’s type (if not `dynamic`) has a `foo` method that accepts a `String` as its first argument and `a.bar`’s type as its second. If the code is sufficiently typed, runtime checks are unnecessary.
diff --git a/pkg/dev_compiler/doc/RUNTIME_SAFETY.md b/pkg/dev_compiler/doc/RUNTIME_SAFETY.md
deleted file mode 100644
index 8c86c10..0000000
--- a/pkg/dev_compiler/doc/RUNTIME_SAFETY.md
+++ /dev/null
@@ -1,198 +0,0 @@
-# Strong Mode in the Dart Dev Compiler
-
-## Overview
-
-In the Dart Dev Compiler (DDC), [static strong mode](STATIC_SAFETY.md) checks are augmented with stricter runtime behavior. Together, they enforce the soundness of Dart type annotations.
-
-In general, and in contrast to Dart's checked mode, most safety is enforced statically, at analysis time. DDC exploits this to generate relatively few runtime checks while still providing stronger guarantees than checked mode.
-
-In particular, DDC adds the following:
-
- - Stricter (but fewer) runtime type checks
- - Reified type narrowing
- - Restricted `is`/`as` checks
-
-In all these cases, DDC (with static checks) is stricter than standard checked mode (or production mode). It may reject (either statically or at runtime) programs that run correctly in checked mode (similar to how checked mode may reject programs that run in production mode).
-
-On the other hand, programs that statically check and run correctly in DDC should also run the same in checked mode. A caveat to note is that mirrors (or `runtimeType`) may show a more narrow type in DDC (though, in practice, programmers are discouraged from using these features for performance / code size reasons).
-
-## Runtime checks
-
-In practice, strong mode enforces most type annotations at compile time, and, thus, requires less work at runtime to enforce safety. Consider the following Dart code:
-
-```dart
-String foo(Map<int, String> map, int x) {
- return map[x.abs()];
-}
-```
-
-Strong mode enforces that the function `foo` is only invoked in a manner consistent with its signature. DDC - which assumes strong mode static checking - inserts no further runtime checks. In contrast, standard Dart checked mode would check the type of the parameters -- `map` and `x` -- along with the type of the return value at runtime on every invocation of `foo`. Even Dart production mode, depending on the implementation and its ability to optimize, may require similar checking to dynamically dispatch the map lookup and the method call in the body of `foo`.
-
-Nevertheless, there are cases where DDC still requires runtime checks. (Note: DDC may eventually provide a mode to elide these checks, but this would violate soundness and is beyond the scope of this document.)
-
-### Implicit casts
-
-Dart has flexible assignability rules. Programmers are not required to explicitly cast from supertypes to subtypes. For example, the following is valid Dart:
-
-```dart
-Object o = ...;
-String s = o; // Implicit downcast
-String s2 = s.substring(1);
-```
-
-The assignment to `s` is an implicit downcast from `Object` to `String` and triggers a runtime check in DDC to ensure it is correct.
-
-Note that checked mode would also perform this runtime test. Unlike checked mode, DDC would not require a check on the assignment to `s2` - this type is established statically.
-
-### Inferred variables
-
-Dart's inference may narrow the static type of certain variables. If the variable is mutable, DDC enforces the narrower type at runtime when necessary.
-
-In the following example, strong mode will infer of the type of the local variable `y` as an `int`:
-
-```dart
-int bar(Object x) {
- var y = 0;
- if (x != null) {
- y = x;
- }
- return y.abs();
-}
-```
-
-This allows it to, for example, static verify the call to `y.abs()` and determine that it returns an `int`. However, the parameter `x` is typed as `Object` and the assignment from `x` to `y` now requires a type check to ensure that `y` is only assigned an `int`.
-
-Note, strong mode and DDC are conservative by enforcing a tighter type than required by standard Dart checked mode. For example, checked mode would accept a non-`int` `x` with an `abs` method that happened to return an `int`. In strong mode, a programmer would have to explicitly opt into this behavior by annotating `y` as an `Object` or `dynamic`.
-
-### Covariant generics
-
-Strong mode preserves the covariance of Dart's generic classes. To support this soundly, DDC injects runtime checks on parameters in method invocations whose type is a class type parameter. Consider the call to `baz` in the parameterized class `A`:
-
-```dart
-class A<T> {
- T baz(T x, int y) => x;
-}
-
-void foo(A<Object> a) {
- a.baz(42, 38);
-}
-
-void main() {
- var aString = new A<String>();
- foo(aString);
-}
-```
-
-Statically, sound mode will not generate an error or warning on this code. The call to `baz` in `foo` is statically valid as `42` is an `Object` (as required by the static type of `a`). However, the runtime type of `a` in this example is the narrower `A<String>`. At runtime, when baz is executed, DDC will check that the type of `x` matches the reified type parameter and, in this example, fail.
-
-Note, only `x` requires a runtime check. Unlike checked mode, no runtime check is required for `y` or the return value. Both are statically verified.
-
-### Dynamic operations
-
-Strong mode allows programmers to explicitly use `dynamic` as a type. It also allows programmers to omit types, and in some of these cases inference may fall back on `dynamic` if it cannot determine a static type. In these cases, DDC inserts runtime checks (typically in the form of runtime helper calls).
-
-For example, in the following:
-
-```dart
-int foo(int x) => x + 1;
-
-void main() {
- dynamic bar = foo;
- bar("hello"); // DDC runtime error
-}
-```
-
-`foo` (via `bar`) is incorrectly invoked on a `String`. There is no static error as `bar` is typed `dynamic`. Instead DDC, performs extra runtime checking on the invocation of `bar`. In this case, it would generate a runtime type error. Note, if the type of `bar` had been omitted, it would have been inferred, and the error would have been reported statically.
-
-Nevertheless, there are situations where programmers may prefer a dynamic type for flexibility.
-
-## Runtime type Narrowing
-
-Strong mode statically infers tighter types for functions and generics. In DDC, this is reflected in the reified type at runtime. This allows DDC to enforce the stricter type soundly at runtime when necessary.
-
-In particular, this means that DDC may have a stricter concrete runtime type than other Dart implementations for generic classes and functions. The DDC type will always be a subtype.
-
-This will impact execution in the following ways:
- - DDC may trigger runtime errors where checked mode is forgiving.
- - Code that uses reflection may observe a narrower type in DDC.
-
-### Allocation inference
-
-When strong infers a narrower type for a closure literal or other allocation expression, DDC reifies this narrower type at runtime. As a result, it can soundly enforce typing errors at runtime.
-
-The following is an example of where static checking fails to catch a typing error:
-
-```dart
-apply(int g(x), y) {
- print(g(y));
-}
-
-typedef int Int2Int(int x);
-
-void main() {
- Int2Int f = (x) => x + x;
- apply(f, "hello");
-}
-```
-
-A programmer examining `apply` would reasonably expect it to print an `int` value. The analyzer (with or without strong mode) fails to report a problem. Standard Dart checked simply prints `"hellohello"`. In DDC, however, a runtime error is thrown on the application of `g` in `apply`. The closure literal assigned to `f` in `main` is reified as an `int -> int`, and DDC enforces this at runtime.
-
-In this example, if `apply` and its parameters were fully typed, strong mode would report a static error, and DDC would impose no runtime check.
-
-### Generic methods
-
-[Note: This is not yet implemented correctly.](https://github.com/dart-lang/dev_compiler/issues/301)
-
-Similarly, DDC requires that [generic methods](GENERIC_METHODS.md) return the correct reified type. In strong mode, `Iterable.map` is a generic method. In DDC, `lengths` in `main` will have a reified type of `List<int>`. In `foo`, this will trigger a runtime error when a string is added to the list.
-
-```dart
-void foo(List l) {
- l.add("a string");
-}
-
-void main() {
- Iterable<String> list = <String>["hello", "world"];
- List<int> lengths = list.map((x) => x.length).toList();
- foo(lengths);
- print(lengths[2]);
-}
-```
-
-Standard checked mode would print `"a string"` without error.
-
-## Is / As restrictions
-
-In standard Dart, `is` and `as` runtime checks expose the unsoundness of the type system in certain cases. For example, consider:
-
-```dart
-var list = <dynamic>["hello", "world"];
-if (list is List<int>) {
- ...
-} else if (list is List<String>) {
- ...
-}
-```
-
-Perhaps surprisingly, the first test - `list is List<int>` - evaluates to true here. Such code is highly likely to be erroneous.
-
-Strong mode provides a stricter subtyping check and DDC enforces this at runtime. For compatibility with standard Dart semantics, however, DDC throws a runtime error when an `is` or `as` check would return a different answer with strong mode typing semantics.
-
-In the example above, the first `is` check would generate a runtime error.
-
-Note, we are exploring making this a static error or warning in strong mode. In general, an expression:
-
-```dart
-x is T
-```
-
-or
-
-```dart
-x as T
-```
-
-is only guaranteed safe when `T` is a *ground type*:
-
-- A non-generic class type (e.g., `Object`, `String`, `int`, ...).
-- A generic class type where all type parameters are implicitly or explicitly `dynamic` (e.g., `List<dynamic>`, `Map`, …).
-- A function type where the return type and all parameter types are `dynamic` (e.g., (`dynamic`, `dynamic`) -> `dynamic`, ([`dynamic`]) -> `dynamic`).
diff --git a/pkg/dev_compiler/doc/STATIC_SAFETY.md b/pkg/dev_compiler/doc/STATIC_SAFETY.md
deleted file mode 100644
index 4710af4..0000000
--- a/pkg/dev_compiler/doc/STATIC_SAFETY.md
+++ /dev/null
@@ -1,530 +0,0 @@
-# Strong Mode Static Checking
-
-**Note: This document is out of date. Please see [Sound Dart](https://dart.dev/guides/language/sound-dart) for up-to-date
-documentation on Dart's type system. The work below was a precursor towards Dart's current type system.**
-
-## Overview
-
-The Dart programming language has an optional, unsound type system. Although it is similar in appearance to languages such as Java, C#, or C++, its type system and static checking are fundamentally different. It permits erroneous behavior in ways that may be surprising to programmers coming from those and other conventional typed languages.
-
-In Dart, static type annotations can be often misleading. Dart code such as:
-
-```dart
- var list = ["hello", "world"];
- List<int> listOfInts = list;
-```
-
-produces neither static nor runtime errors. Actual errors may show up much later on, e.g., with the following code, only at runtime on the invocation of `abs`:
-
-```dart
- Iterable<int> iterableOfInts = listOfInts.map((i) => i.abs());
-```
-
-Strong mode aims to catch such errors early by validating that variables - e.g., `listOfInts` - actually match their corresponding static type annotations - e.g., `List<int>`. It constrains the Dart programming language to a subset of programs that type check under a restricted set of rules. It statically rejects examples such as the above.
-
-To accomplish this, strong mode involves the following:
-
- - **Type inference**. Dart’s standard type rules treats untyped variables as `dynamic`, which
-suppresses any static warnings on them. Strong mode infers static types based upon context. In the example above, strong mode infers that `list` has type `List`. Note, in strong mode, programmers may still explicitly use the `dynamic` type.
-
- - **Strict subtyping**. Dart’s primary sources of unsoundness are due to its subtyping rules on function types and generic classes. Strong mode restricts these: e.g., `List` may not used as `List<int>` in the example above.
-
- - **Generic methods**. Standard Dart does not yet provide generic methods. This makes certain polymorphic methods difficult to use soundly. For example, the `List.map` invocation above is statically typed to return an `Iterable<dynamic>` in standard Dart. Strong mode allows methods to be annotated as generic. `List.map` is statically typed to return an `Iterable<T>` where `T` is bound to `int` in the previous example. A number of common higher-order methods are annotated and checked as generic in strong mode, and programmers may annotate their own methods as well.
-
-Strong mode is designed to work in conjunction with the Dart Dev Compiler (DDC), which uses static type verification to generate better code. DDC augments strong mode static checking with a minimal set of [runtime checks](RUNTIME_SAFETY.md) that aim to provide full soundness of types.
-
-Strong mode static analysis may also be used alone for stricter error checking.
-
-Formal details of the strong mode type system may be found [here](https://dart-lang.github.io/dev_compiler/strong-dart.pdf).
-
-## Usage
-
-Strong mode is now integrated into the Dart Analyzer. The analyzer may be invoked in strong mode as follows:
-
- $ dartanalyzer --strong myapp.dart
-
-Strong mode may also be enabled in IDEs by creating (if necessary) an `.analysis_options` file in your project and appending the following entry to it:
-
-```
-analyzer:
- strong-mode: true
-```
-
-## Type Inference
-
-With strong mode, we want to provide stronger typing while preserving the
-terseness of Dart. [Idiomatic Dart
-code](https://dart.dev/guides/language/effective-dart) discourages type annotations
-outside of API boundaries, and user shouldn't have to add more types to get
-better checking. Instead, strong mode uses type inference.
-
-In Dart, per the specification, the static type of a variable `x` declared as:
-
-```dart
-var x = <String, String>{ "hello": "world"};
-```
-
-is `dynamic` as there is no explicit type annotation on the left-hand side. To discourage code bloat, the Dart style guide generally recommends omitting these type annotations in many situations. In these cases, the benefits of strong mode would be lost.
-
-To avoid this, strong mode uses type inference. In the case above, strong mode infers and enforces the type of `x` as `Map<String, String>`. An important aspect to inference is ordering: when an inferred type may be used to infer another type. To maximize the impact, we perform the following inference:
-
-- Top-level and static fields
-- Instance fields and methods
-- Local variables
-- Constructor calls and literals
-- Generic method invocations
-
-Inference may tighten the static type as compared to the Dart specification. An implicitly dynamic type, either alone or in the context of a function or generic parameter type, is inferred to a more specific type. This inference may result in stricter type errors than standard Dart.
-
-In [DDC](RUNTIME_SAFETY.md), inference may also affect the reified runtime type.
-
-### Top-level and Static Fields
-
-Strong mode infers any untyped top-level field or static field from the type of
-its initializer. The static type of the declared variable is inferred as the static type of the initializer. For example, consider:
-
-```dart
-var PI = 3.14159;
-var radius = 2;
-var circumference = 2 * PI * radius;
-```
-
-Strong mode infers the static type of `PI` as `double` and `radius` as `int` directly from their initializers. It infers the static type of `circumference` as `double`, transitively using the other inferred types. Standard Dart rules would treat all of these static types as `dynamic`. Note that the following later assignment would be allowed in standard Dart, but disallowed (as a static type error) in strong mode:
-```dart
-radius = "five inches";
-```
-Strong mode inference avoids circular dependences. If a variable’s initializer expression refers to another variable whose type would be dependent (directly or indirectly) on the first, the static type of that other variable is treated as `dynamic` for the purpose of inference.
-
-### Instance Fields and Methods
-
-Strong mode performs two types of inference on instance fields and methods.
-
-The first uses base types to constrain overrides in subtypes. Consider the following example:
-
-```dart
-abstract class A {
- Map get m;
- int value(int i);
-}
-
-class B extends A {
- var m;
- value(i) => m[i];
- …
-}
-```
-
-In Dart, overridden method, getter, or setter types should be subtypes of the corresponding base class ones (otherwise, static warnings are given). In standard Dart, the above declaration of `B` is not an error: both `m`’s getter type and `value`’s return type are `dynamic`.
-
-Strong mode -- without inference -- would disallow this: if `m` in `B` could be assigned any kind of object, including one that isn't a Map, it would violate the type contract in the declaration of `A`.
-
-However, rather than rejecting the above code, strong mode employs inference to tighten the static types to obtain a valid override. The corresponding types in B are inferred as if it was:
-
-```dart
-class B extends A {
- Map m;
- int value(int i) => m[i];
- …
-}
-```
-
-Note that tightening the argument type for `i` to `int` is not required for soundness; it is done for convenience as it is the typical intent. The programmer may explicitly type this as `dynamic` or `Object` to avoid inferring the narrower type.
-
-The second form inference is limited to instance fields (not methods) and is similar to that on static fields. For instance fields where the static type is omitted and an initializer is present, the field’s type is inferred as the initializer’s type. In this continuation of our example:
-
-```dart
-class C extends A {
- var y = 42;
- var m = <int, int>{ 0: 38};
- ...
-}
-```
-
-the instance field `y` has inferred type `int` based upon its initializer. Note that override-based inference takes precedence over initializer-based inference. The instance field `m` has inferred type `Map`, not `Map<int, int>` due to the corresponding declaration in `A`.
-
-### Local Variables
-
-As with fields, local variable types are inferred if the static type is omitted and an initializer expression is present. In the following example:
-
-```dart
-Object foo(int x) {
- final y = x + 1;
- var z = y * 2;
- return z;
-}
-```
-
-the static types of `y` and `z` are both inferred as `int` in strong mode. Note that local inference is done in program order: the inferred type of `z` is computed using the inferred type of `y`. Local inference may result in strong mode type errors in otherwise legal Dart code. In the above, a second assignment to `z` with a string value:
-```dart
-z = "$z";
-```
-would trigger a static error in strong mode, but is allowed in standard Dart. In strong mode, the programmer must use an explicit type annotation to suppress inference. Explicitly declaring `z` with the type `Object` or `dynamic` would suffice in this case.
-
-### Constructor Calls and Literals
-
-Strong mode also performs contextual inference on allocation expressions. This inference is rather different from the above: it tightens the runtime type of the corresponding expression using the static type of its context. Contextual inference is used on expressions that allocate a new object: closure literals, map and list literals, and explicit constructor invocations (i.e., via `new` or `const`).
-
-In DDC, these inferred types are also [reified at runtime](RUNTIME_SAFETY.md) on the newly allocated objects to provide a stronger soundness guarantee.
-
-#### Closure literals
-
-Consider the following example:
-
-```dart
-int apply(int f(int arg), int value) {
- return f(value);
-}
-
-void main() {
- int result =
- apply((x) { x = x * 9 ~/ 5; return x + 32; }, 41);
- print(result);
-}
-```
-
-The function `apply` takes another function `f`, typed `(int) -> int`, as its first argument. It is invoked in `main` with a closure literal. In standard Dart, the static type of this closure literal would be `(dynamic) -> dynamic`. In strong mode, this type cannot be safely converted to `(int) -> int` : it may return a `String` for example.
-
-Dart has a syntactic limitation in this case: it is not possible to statically annotate the return type of a closure literal.
-
-Strong mode sidesteps this difficulty via contextual inference. It infers the closure type as `(int) -> int`. Note, this may trigger further inference and type checks in the body of the closure.
-
-#### List and map literals
-
-Similarly, strong mode infers tighter runtime types for list and map literals. E.g., in
-
-```dart
-List<String> words = [ "hello", "world" ];
-```
-
-the runtime type is inferred as `List<String>` in order to match the context of the left hand side. In other words, the code above type checks and executes as if it was:
-
-```dart
-List<String> words = <String>[ "hello", "world" ];
-```
-
-Similarly, the following will now trigger a static error in strong mode:
-
-```dart
-List<String> words = [ "hello", 42 ]; // Strong Mode Error: 42 is not a String
-```
-
-Contextual inference may be recursive:
-
-```dart
-Map<List<String>, Map<int, int>> map =
- { ["hello"]: { 0: 42 }};
-```
-
-In this case, the inner map literal is inferred as a `Map<int, int>`. Note, strong mode will statically reject code where the contextually required type is not compatible. This will trigger a static error:
-
-```dart
-Map<List<String>, Map<int, int>> map =
- { ["hello"]: { 0: "world" }}; // STATIC ERROR
-```
-
-as "world" is not of type `int`.
-
-#### Constructor invocations
-
-Finally, strong mode performs similar contextual inference on explicit constructor invocations via `new` or `const`. For example:
-
-```dart
-Set<String> string = new Set.from(["hello", "world"]);
-```
-
-is treated as if it was written as:
-
-```dart
-Set<String> string =
- new Set<String>.from(<String>["hello", "world"]);
-```
-
-Note, as above, context is propagated downward into the expression.
-
-## Strict subtyping
-
-The primary sources of unsoundness in Dart are generics and functions. Both introduce circularity in the Dart subtyping relationship.
-
-### Generics
-
-Generics in Dart are covariant, with the added rule that the `dynamic` type may serve as both ⊤ (top) and ⊥ (bottom) of the type hierarchy in certain situations. For example, let *<:<sub>D</sub>* represent the standard Dart subtyping rule. Then, for all types `S` and `T`:
-
-`List<S>` <:<sub>D</sub> `List<dynamic>` <:<sub>D</sub> `List<T>`
-
-where `List` is equivalent to `List<dynamic>`. This introduces circularity - e.g.:
-
-`List<int>` <:<sub>D</sub> `List` <:<sub>D</sub> `List<String>`<:<sub>D</sub> `List` <:<sub>D</sub> `List<int>`
-
-From a programmer’s perspective, this means that, at compile-time, values that are statically typed `List<int>` may later be typed `List<String>` and vice versa. At runtime, a plain `List` can interchangeably act as a `List<int>` or a `List<String>` regardless of its actual values.
-
-The example taken from [here](https://github.com/dart-lang/dev_compiler/blob/strong/STRONG_MODE.md#motivation) exploits this:
-
-```dart
-class MyList extends ListBase<int> implements List {
- Object length;
-
- MyList(this.length);
-
- operator[](index) => "world";
- operator[]=(index, value) {}
-}
-```
-
-A `MyList` may masquerade as a `List<int>` as it is transitively a subtype:
-
-`MyList` <:<sub>D</sub> `List` <:<sub>D</sub>`List<int>`
-
-In strong mode, we introduce a stricter subtyping rule <:<sub>S</sub> to disallow this. In this case, in the context of a generic type parameter, dynamic may only serve as ⊤. This means that this is still true:
-
-`List<int>` <:<sub>S</sub> `List`
-
-but that this is not:
-
-`List` ~~<:<sub>S</sub> `List<int>`~~
-
-The example above fails in strong mode:
-
-`MyList` <:<sub>S</sub> `List` ~~<:<sub>S</sub> `List<int>`~~
-
-
-### Functions
-
-The other primary source of unsoundness in Dart is function subtyping. An unusual feature of the Dart type system is that function types are bivariant in both the parameter types and the return type (see Section 19.5 of the [Dart specification][dartspec]). As with generics, this leads to circularity:
-
-`(int) -> int` <:<sub>D</sub> `(Object) -> Object` <:<sub>D</sub> `(int) -> int`
-
-And, as before, this can lead to surprising behavior. In Dart, an overridden method’s type should be a subtype of the base class method’s type (otherwise, a static warning is given). In our running example, the (implicit) `MyList.length` getter has type:
-
-`() -> Object`
-
-while the `List.length` getter it overrides has type:
-
-`() -> int`
-
-This is valid in standard Dart as:
-
-`() -> Object` <:<sub>D</sub> `() -> int`
-
-Because of this, a `length` that returns "hello" (a valid `Object`) triggers no static or runtime warnings or errors.
-
-Strong mode enforces the stricter, [traditional function subtyping](https://en.wikipedia.org/wiki/Subtyping#Function_types) rule: subtyping is contravariant in parameter types and covariant in return types. This permits:
-
-`() -> int` <:<sub>S</sub> `() -> Object`
-
-but disallows:
-
-`() -> Object` <:<sub>S</sub> `() -> int`
-
-With respect to our example, strong mode requires that any subtype of a List have an int-typed length. It statically rejects the length declaration in MyList.
-
-## Generic Methods
-
-Strong mode introduces generic methods to allow more expressive typing on polymorphic methods. Such code in standard Dart today often loses static type information. For example, the `Iterable.map` method is declared as below:
-
-```dart
-abstract class Iterable<E> {
- ...
- Iterable map(f(E e));
-}
-```
-
-Regardless of the static type of the function `f`, the `map` always returns an `Iterable<dynamic>` in standard Dart. As result, standard Dart tools miss the obvious error on the following code:
-
-```dart
-Iterable<int> results = <int>[1, 2, 3].map((x) => x.toString()); // Static error only in strong mode
-```
-
-The variable `results` is statically typed as if it contains `int` values, although it clearly contains `String` values at runtime.
-
-The [generic methods proposal](https://github.com/leafpetersen/dep-generic-methods/blob/master/proposal.md) adds proper generic methods to the Dart language as a first class language construct and to make methods such as the `Iterable.map` generic.
-
-To enable experimentation, strong mode provides a [generic methods prototype](GENERIC_METHODS.md) based on the existing proposal, but usable on all existing Dart implementations today. Strong mode relies on this to report the error on the example above.
-
-The `Iterable.map` method is now declared as follows:
-
-```dart
-abstract class Iterable<E> {
- ...
- Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E e));
-}
-```
-
-At a use site, the generic type may be explicitly provided or inferred from context:
-
-```
- var l = <int>[1, 2, 3];
- var i1 = l.map((i) => i + 1);
- var l2 = l.map/*<String>*/((i) { ... });
-```
-
-In the first invocation of `map`, the closure is inferred (from context) as `int -> int`, and the generic type of map is inferred as `int` accordingly. As a result, `i1` is inferred as `Iterable<int>`. In the second, the type parameter is explicitly bound to `String`, and the closure is checked against this type. `i2` is typed as `Iterable<String>`.
-
-Further details on generic methods in strong mode and in DDC may be found [here](GENERIC_METHODS.md).
-
-## Additional Restrictions
-
-In addition to stricter typing rules, strong mode enforces other
-restrictions on Dart programs.
-
-### Warnings as Errors
-
-Strong mode effectively treats all standard Dart static warnings as static errors. Most of these warnings are required for soundness (e.g., if a concrete class is missing methods required by a declared interface). A full list of Dart static warnings may found in the [Dart specification][dartspec], or enumerated here:
-
-[https://github.com/dart-lang/sdk/blob/main/pkg/analyzer/lib/src/generated/error.dart#L3772](https://www.google.com/url?q=https%3A%2F%2Fgithub.com%2Fdart-lang%2Fsdk%2Fblob%2Fmaster%2Fpkg%2Fanalyzer%2Flib%2Fsrc%2Fgenerated%2Ferror.dart%23L3772&sa=D&sntz=1&usg=AFQjCNFc4E37M1PshVcw4zk7C9jXgqfGbw)
-
-### Super Invocations
-
-In the context of constructor initializer lists, strong mode restricts `super` invocations to the end. This restriction simplifies generated code with minimal effect on the program.
-
-### For-in loops
-
-In for-in statements of the form:
-
-```dart
-for (var i in e) { … }
-```
-
-Strong mode requires the expression `e` to be an `Iterable`. When the loop variable `i` is also statically typed:
-
-```dart
-for (T i in e) { … }
-```
-
-the expression `e` is required to be an `Iterable<T>`.
-
-*Note: we may weaken these.*
-
-### Field overrides
-
-By default, fields are overridable in Dart.
-
-```dart
-int init(int n) {
- print('Initializing with $n');
- return n;
-}
-
-class A {
- int x = init(42);
-}
-
-class B extends A {
- int x;
-}
-```
-
-Disallow overriding fields: this results in complicated generated
-code where a field definition in a subclass shadows the field
- definition in a base class but both are generally required to be
- allocated. Users should prefer explicit getters and setters in such
- cases. See [issue 52](https://github.com/dart-lang/dev_compiler/issues/52).
-
-## Optional Features
-
-### Disable implicit casts
-
-This is an optional feature of strong mode. It disables implicit down casts. For example:
-
-```dart
-main() {
- num n = 0.5;
- int x = n; // error: invalid assignment
- int y = n as int; // ok at compile time, might fail when run
-}
-```
-
-Casts from `dynamic` must be explicit as well:
-
-```dart
-main() {
- dynamic d = 'hi';
- int x = d; // error: invalid assignment
- int y = d as int; // ok at compile time, might fail when run
-}
-```
-
-This option is experimental and may be changed or removed in the future.
-Try it out in your project by editing .analysis_options:
-
-```yaml
-analyzer:
- strong-mode:
- implicit-casts: False
-```
-
-Or pass `--no-implicit-casts` to Dart Analyzer:
-
-```
-dartanalyzer --strong --no-implicit-casts my_app.dart
-```
-
-### Disable implicit dynamic
-
-This is an optional feature of analyzer, intended primarily for use with strong mode's inference.
-It rejects implicit uses of `dynamic` that strong mode inference fails to fill in with a concrete type,
-ensuring that all types are either successfully inferred or explicitly written. For example:
-
-```dart
-main() {
- var x; // error: implicit dynamic
- var i = 123; // okay, inferred to be `int x`
- dynamic y; // okay, declared as dynamic
-}
-```
-
-This also affects: parameters, return types, fields, creating objects with generic type, generic functions/methods, and
-supertypes:
-
-```dart
-// error: parameters and return types are implicit dynamic
-f(x) => x + 42;
-dynamic f(dynamic x) => x + 42; // okay
-int f(int x) => x + 42; // okay
-
-class C {
- var f; // error: implicit dynamic field
- dynamic f; // okay
-}
-
-main() {
- var x = []; // error: implicit List<dynamic>
- var y = [42]; // okay: List<int>
- var z = <dynamic>[]; // okay: List<dynamic>
-
- T genericFn<T>() => null;
- genericFn(); // error: implicit genericFn<dynamic>
- genericFn<dynamic>(); // okay
- int x = genericFn(); // okay, inferred genericFn<int>
-}
-
-// error: implicit supertype Iterable<dynamic>
-class C extends Iterable { /* ... */ }
-// okay
-class C extends Iterable<dynamic> { /* ... */ }
-```
-
-This feature is to prevent accidental use of `dynamic` in code that does not intend to use it.
-
-This option is experimental and may be changed or removed in the future.
-Try it out in your project by editing .analysis_options:
-
-```yaml
-analyzer:
- strong-mode:
- implicit-dynamic: False
-```
-
-Or pass `--no-implicit-dynamic` to Dart Analyzer:
-
-```
-dartanalyzer --strong --no-implicit-dynamic my_app.dart
-```
-
-### Open Items
-
-- Is / As restrictions: Dart's `is` and `as` checks are unsound for certain types
-(generic classes, certain function types). In [DDC](RUNTIME_SAFETY.md), problematic
-`is` and `as` checks trigger runtime errors. We are considering introducing static
-errors for these cases.
-
-[dartspec]: https://dart.dev/guides/language/spec "Dart Language Spec"
diff --git a/pkg/dev_compiler/doc/definition/macros.tex b/pkg/dev_compiler/doc/definition/macros.tex
deleted file mode 100644
index a5e4a1e..0000000
--- a/pkg/dev_compiler/doc/definition/macros.tex
+++ /dev/null
@@ -1,67 +0,0 @@
-%%% Cascaded items for math mode
-%% start with \begin{cascade}
-%% new line at previous indentation with \cascline
-%% new line with greater indentation with \cascitem
-%% end with \end{cascade}
-%% default indentation is 2em, adjust with \cascadeindent
-\newdimen\cascadeindent
-\cascadeindent=1em\newdimen\cascdimen
-\newcommand{\cascindent}{\global\advance\cascdimen by\cascadeindent \hspace{\cascdimen}}
-\newcommand{\cascitem}{\\ \global\advance\cascdimen by\cascadeindent \hspace{\cascdimen}}
-\newcommand{\cascback}[1]{\\ \global\advance\cascdimen by-#1.0\cascadeindent \hspace{\cascdimen}}
-\newcommand{\cascline}{\\ \hspace{\cascdimen}}
-\newenvironment{cascade}{\begin{array}[t]{@{}l@{}} \global\cascdimen=0em}{\end{array}}
-
-
-%%% Binding colon stuff
-\mathchardef\col="003A % \col for binding colon (mathcode ordinary: less space)
-\mathchardef\semi="603B % \semi for (regular) semicolon
-%% use \semicolonforbindingcolon to redefine ; to stand for binding colon
-\newcommand{\semicolonforbindingcolon}{\mathcode`;="003A}
-
-%%% Angle bracket stuff
-\mathchardef\lt="313C % \lt for <
-\mathchardef\gt="313E % \gt for >
-%% use \ltgtforanglebrackets to redefine <,> to stand for \langle, \rangle
-\newcommand{\ltgtforanglebrackets}{\mathcode`<="4268 \mathcode`>="5269}
-
-\newcommand{\kwop}[1]{\ensuremath{\mathop{\mathbf{#1}}}}
-\newcommand{\kwbin}[1]{\ensuremath{\mathbin{\mathbf{#1}}}}
-\newcommand{\kw}[1]{\ensuremath{\mathord{\mathbf{#1}}}}
-
-\newcommand{\comment}[1]{\hfill \fbox{\Large{#1}}}
-
-%\newcommand{\qed}{\rule{5pt}{8pt}}
-\newcommand{\thmbox}
- {{\ \hfill\hbox{%
- \vrule width1.0ex height1.0ex
- }\parfillskip 0pt}}
-
-\newenvironment{proof}{{\textbf{Proof:} }}{\thmbox}
-\newenvironment{proofsketch}{{\textbf{Proof (Sketch):} }}{\thmbox}
-
-\newcommand{\thmstep}[2]{
- \noindent\begin{tabular}{@{}l@{}l}
- \lefteqn{\mbox{#1}} &\\
- \mbox{ } & $\begin{array}{l}#2\end{array}$
- \end{tabular}
- }
-
-\newcommand{\thmstepp}[2]{
- \noindent\begin{tabular}{lll}
- \lefteqn{\mbox{#1}} &\\
- \mbox{ } & #2
- \end{tabular}
- }
-
-\newcommand{\ifthenthm}[2]{
- \noindent\begin{tabular}[t]{@{}l@{}l}
- If & \\
- & $\begin{array}[t]{l}#1\end{array}$ \\
- then & \\
- & $\begin{array}[t]{l}#2\end{array}$
- \end{tabular}
- }
-
-% symbol abbreviations
-\newcommand{\stepsto}{\longmapsto}
diff --git a/pkg/dev_compiler/doc/definition/proof.sty b/pkg/dev_compiler/doc/definition/proof.sty
deleted file mode 100644
index c272a81..0000000
--- a/pkg/dev_compiler/doc/definition/proof.sty
+++ /dev/null
@@ -1,259 +0,0 @@
-% proof.sty (Proof Figure Macros)
-%
-% version 3.1 (for both LaTeX 2.09 and LaTeX 2e)
-% Nov 24, 2005
-% Copyright (C) 1990 -- 2005, Makoto Tatsuta (tatsuta@nii.ac.jp)
-%
-% This program is free software; you can redistribute it or modify
-% it under the terms of the GNU General Public License as published by
-% the Free Software Foundation; either versions 1, or (at your option)
-% any later version.
-%
-% This program is distributed in the hope that it will be useful
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-% GNU General Public License for more details.
-%
-% Usage:
-% In \documentstyle, specify an optional style `proof', say,
-% \documentstyle[proof]{article}.
-%
-% The following macros are available:
-%
-% In all the following macros, all the arguments such as
-% <Lowers> and <Uppers> are processed in math mode.
-%
-% \infer<Lower><Uppers>
-% draws an inference.
-%
-% Use & in <Uppers> to delimit upper formulae.
-% <Uppers> consists more than 0 formulae.
-%
-% \infer returns \hbox{ ... } or \vbox{ ... } and
-% sets \@LeftOffset and \@RightOffset globally.
-%
-% \infer[<Label>]<Lower><Uppers>
-% draws an inference labeled with <Label>.
-%
-% \infer*<Lower><Uppers>
-% draws a many step deduction.
-%
-% \infer*[<Label>]<Lower><Uppers>
-% draws a many step deduction labeled with <Label>.
-%
-% \infer=<Lower><Uppers>
-% draws a double-ruled deduction.
-%
-% \infer=[<Label>]<Lower><Uppers>
-% draws a double-ruled deduction labeled with <Label>.
-%
-% \deduce<Lower><Uppers>
-% draws an inference without a rule.
-%
-% \deduce[<Proof>]<Lower><Uppers>
-% draws a many step deduction with a proof name.
-%
-% Example:
-% If you want to write
-% B C
-% -----
-% A D
-% ----------
-% E
-% use
-% \infer{E}{
-% A
-% &
-% \infer{D}{B & C}
-% }
-%
-
-% Style Parameters
-
-\newdimen\inferLineSkip \inferLineSkip=2pt
-\newdimen\inferLabelSkip \inferLabelSkip=5pt
-\def\inferTabSkip{\quad}
-
-% Variables
-
-\newdimen\@LeftOffset % global
-\newdimen\@RightOffset % global
-\newdimen\@SavedLeftOffset % safe from users
-
-\newdimen\UpperWidth
-\newdimen\LowerWidth
-\newdimen\LowerHeight
-\newdimen\UpperLeftOffset
-\newdimen\UpperRightOffset
-\newdimen\UpperCenter
-\newdimen\LowerCenter
-\newdimen\UpperAdjust
-\newdimen\RuleAdjust
-\newdimen\LowerAdjust
-\newdimen\RuleWidth
-\newdimen\HLabelAdjust
-\newdimen\VLabelAdjust
-\newdimen\WidthAdjust
-
-\newbox\@UpperPart
-\newbox\@LowerPart
-\newbox\@LabelPart
-\newbox\ResultBox
-
-% Flags
-
-\newif\if@inferRule % whether \@infer draws a rule.
-\newif\if@DoubleRule % whether \@infer draws doulbe rules.
-\newif\if@ReturnLeftOffset % whether \@infer returns \@LeftOffset.
-
-% Special Fonts
-
-\def\DeduceSym{\vtop{\baselineskip4\p@ \lineskiplimit\z@
- \vbox{\hbox{.}\hbox{.}\hbox{.}}\hbox{.}}}
-
-% Macros
-
-% Renaming @ifnextchar and @ifnch of LaTeX2e to @IFnextchar and @IFnch.
-
-\def\@IFnextchar#1#2#3{%
- \let\reserved@e=#1\def\reserved@a{#2}\def\reserved@b{#3}\futurelet
- \reserved@c\@IFnch}
-\def\@IFnch{\ifx \reserved@c \@sptoken \let\reserved@d\@xifnch
- \else \ifx \reserved@c \reserved@e\let\reserved@d\reserved@a\else
- \let\reserved@d\reserved@b\fi
- \fi \reserved@d}
-
-\def\@ifEmpty#1#2#3{\def\@tempa{\@empty}\def\@tempb{#1}\relax
- \ifx \@tempa \@tempb #2\else #3\fi }
-
-\def\infer{\@IFnextchar *{\@inferSteps}{\relax
- \@IFnextchar ={\@inferDoubleRule}{\@inferOneStep}}}
-
-\def\@inferOneStep{\@inferRuletrue \@DoubleRulefalse
- \@IFnextchar [{\@infer}{\@infer[\@empty]}}
-
-\def\@inferDoubleRule={\@inferRuletrue \@DoubleRuletrue
- \@IFnextchar [{\@infer}{\@infer[\@empty]}}
-
-\def\@inferSteps*{\@IFnextchar [{\@@inferSteps}{\@@inferSteps[\@empty]}}
-
-\def\@@inferSteps[#1]{\@deduce{#1}[\DeduceSym]}
-
-\def\deduce{\@IFnextchar [{\@deduce{\@empty}}
- {\@inferRulefalse \@infer[\@empty]}}
-
-% \@deduce<Proof Label>[<Proof>]<Lower><Uppers>
-
-\def\@deduce#1[#2]#3#4{\@inferRulefalse
- \@infer[\@empty]{#3}{\@infer[{#1}]{#2}{#4}}}
-
-% \@infer[<Label>]<Lower><Uppers>
-% If \@inferRuletrue, it draws a rule and <Label> is right to
-% a rule. In this case, if \@DoubleRuletrue, it draws
-% double rules.
-%
-% Otherwise, draws no rule and <Label> is right to <Lower>.
-
-\def\@infer[#1]#2#3{\relax
-% Get parameters
- \if@ReturnLeftOffset \else \@SavedLeftOffset=\@LeftOffset \fi
- \setbox\@LabelPart=\hbox{$#1$}\relax
- \setbox\@LowerPart=\hbox{$#2$}\relax
-%
- \global\@LeftOffset=0pt
- \setbox\@UpperPart=\vbox{\tabskip=0pt \halign{\relax
- \global\@RightOffset=0pt \@ReturnLeftOffsettrue $##$&&
- \inferTabSkip
- \global\@RightOffset=0pt \@ReturnLeftOffsetfalse $##$\cr
- #3\cr}}\relax
- \UpperLeftOffset=\@LeftOffset
- \UpperRightOffset=\@RightOffset
-% Calculate Adjustments
- \LowerWidth=\wd\@LowerPart
- \LowerHeight=\ht\@LowerPart
- \LowerCenter=0.5\LowerWidth
-%
- \UpperWidth=\wd\@UpperPart \advance\UpperWidth by -\UpperLeftOffset
- \advance\UpperWidth by -\UpperRightOffset
- \UpperCenter=\UpperLeftOffset
- \advance\UpperCenter by 0.5\UpperWidth
-%
- \ifdim \UpperWidth > \LowerWidth
- % \UpperCenter > \LowerCenter
- \UpperAdjust=0pt
- \RuleAdjust=\UpperLeftOffset
- \LowerAdjust=\UpperCenter \advance\LowerAdjust by -\LowerCenter
- \RuleWidth=\UpperWidth
- \global\@LeftOffset=\LowerAdjust
-%
- \else % \UpperWidth <= \LowerWidth
- \ifdim \UpperCenter > \LowerCenter
-%
- \UpperAdjust=0pt
- \RuleAdjust=\UpperCenter \advance\RuleAdjust by -\LowerCenter
- \LowerAdjust=\RuleAdjust
- \RuleWidth=\LowerWidth
- \global\@LeftOffset=\LowerAdjust
-%
- \else % \UpperWidth <= \LowerWidth
- % \UpperCenter <= \LowerCenter
-%
- \UpperAdjust=\LowerCenter \advance\UpperAdjust by -\UpperCenter
- \RuleAdjust=0pt
- \LowerAdjust=0pt
- \RuleWidth=\LowerWidth
- \global\@LeftOffset=0pt
-%
- \fi\fi
-% Make a box
- \if@inferRule
-%
- \setbox\ResultBox=\vbox{
- \moveright \UpperAdjust \box\@UpperPart
- \nointerlineskip \kern\inferLineSkip
- \if@DoubleRule
- \moveright \RuleAdjust \vbox{\hrule width\RuleWidth
- \kern 1pt\hrule width\RuleWidth}\relax
- \else
- \moveright \RuleAdjust \vbox{\hrule width\RuleWidth}\relax
- \fi
- \nointerlineskip \kern\inferLineSkip
- \moveright \LowerAdjust \box\@LowerPart }\relax
-%
- \@ifEmpty{#1}{}{\relax
-%
- \HLabelAdjust=\wd\ResultBox \advance\HLabelAdjust by -\RuleAdjust
- \advance\HLabelAdjust by -\RuleWidth
- \WidthAdjust=\HLabelAdjust
- \advance\WidthAdjust by -\inferLabelSkip
- \advance\WidthAdjust by -\wd\@LabelPart
- \ifdim \WidthAdjust < 0pt \WidthAdjust=0pt \fi
-%
- \VLabelAdjust=\dp\@LabelPart
- \advance\VLabelAdjust by -\ht\@LabelPart
- \VLabelAdjust=0.5\VLabelAdjust \advance\VLabelAdjust by \LowerHeight
- \advance\VLabelAdjust by \inferLineSkip
-%
- \setbox\ResultBox=\hbox{\box\ResultBox
- \kern -\HLabelAdjust \kern\inferLabelSkip
- \raise\VLabelAdjust \box\@LabelPart \kern\WidthAdjust}\relax
-%
- }\relax % end @ifEmpty
-%
- \else % \@inferRulefalse
-%
- \setbox\ResultBox=\vbox{
- \moveright \UpperAdjust \box\@UpperPart
- \nointerlineskip \kern\inferLineSkip
- \moveright \LowerAdjust \hbox{\unhbox\@LowerPart
- \@ifEmpty{#1}{}{\relax
- \kern\inferLabelSkip \unhbox\@LabelPart}}}\relax
- \fi
-%
- \global\@RightOffset=\wd\ResultBox
- \global\advance\@RightOffset by -\@LeftOffset
- \global\advance\@RightOffset by -\LowerWidth
- \if@ReturnLeftOffset \else \global\@LeftOffset=\@SavedLeftOffset \fi
-%
- \box\ResultBox
-}
diff --git a/pkg/dev_compiler/doc/definition/static-semantics.tex b/pkg/dev_compiler/doc/definition/static-semantics.tex
deleted file mode 100644
index b103d95..0000000
--- a/pkg/dev_compiler/doc/definition/static-semantics.tex
+++ /dev/null
@@ -1,1062 +0,0 @@
-\subsection*{Field lookup}
-
-\infrule{(C : \dclass{\TApp{C}{T_0,\ldots,T_n}}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{\many{\mathit{ce}}}) \in \Phi \\
- \fieldDecl{x}{\tau} \in \many{\mathit{ce}}
- }
- {\fieldLookup{\Phi}{\TApp{C}{\tau_0, \ldots, \tau_n}}{x}{\subst{\tau_0, \ldots, \tau_n}{T_0, \ldots, T_n}{\tau}}
- }
-
-\infrule{(C : \dclass{\TApp{C}{T_0,\ldots,T_n}}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{\many{\mathit{ce}}}) \in \Phi \quad x \notin \many{\mathit{ce}} \\
- \fieldLookup{\Phi}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{x}{\tau}
- }
- {\fieldLookup{\Phi}{\TApp{C}{\tau_0, \ldots, \tau_n}}{x}{\subst{\tau_0, \ldots, \tau_n}{T_0, \ldots, T_n}{\tau}}
- }
-
-
-\subsection*{Method lookup}
-
-\infrule{(C : \dclass{\TApp{C}{T_0,\ldots,T_n}}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{\many{\mathit{ce}}}) \in \Phi \\
- \methodDecl{m}{\tau}{\sigma} \in \many{\mathit{ce}}
- }
- {\methodLookup{\Phi}
- {\TApp{C}{\tau_0, \ldots, \tau_n}}{m}
- {\subst{\tau_0, \ldots, \tau_n}{T_0, \ldots, T_n}{\tau}}
- {\subst{\tau_0, \ldots, \tau_n}{T_0, \ldots, T_n}{\sigma}}
- }
-
-\infrule{(C : \dclass{\TApp{C}{T_0,\ldots,T_n}}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{\many{\mathit{ce}}}) \in \Phi \quad m \notin \many{\mathit{ce}} \\
- \methodLookup{\Phi}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{m}{\tau}{\sigma}
- }
- {\methodLookup{\Phi}{\TApp{C}{\tau_0, \ldots, \tau_n}}{m}
- {\subst{\tau_0, \ldots, \tau_n}{T_0, \ldots, T_n}{\tau}}
- {\subst{\tau_0, \ldots, \tau_n}{T_0, \ldots, T_n}{\sigma}}
- }
-
-\subsection*{Method and field absence}
-
-\infrule{(C : \dclass{\TApp{C}{T_0,\ldots,T_n}}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{\many{\mathit{ce}}}) \in \Phi \quad x \notin \many{\mathit{ce}} \\
- \fieldAbsent{\Phi}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{x}
- }
- {\fieldAbsent{\Phi}{\TApp{C}{\tau_0, \ldots, \tau_n}}{x}
- }
-
-\infrule{(C : \dclass{\TApp{C}{T_0,\ldots,T_n}}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{\many{\mathit{ce}}}) \in \Phi \quad m \notin \many{\mathit{ce}} \\
- \methodAbsent{\Phi}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{m}{\tau}{\sigma}
- }
- {\methodAbsent{\Phi}{\TApp{C}{\tau_0, \ldots, \tau_n}}{m}
- }
-
-\iftrans{
-
-\subsection*{Type translation}
-
-To translate covariant generics, we essentially want to treat all contravariant
-occurrences of type variables as $\Dynamic$. The type translation
-$\down{\tau}$ implements this. It is defined in terms of the dual operator
-$\up{\tau}$ which translates positive occurences of type variables as $\Dynamic$.
-
-\begin{eqnarray*}
- \down{T} & = & T \\
- \down{\Arrow[k]{\tau_0, \ldots, \tau_n}{\tau_r}} & = &
- \Arrow[k]{\up{\tau_0}, \ldots, \up{\tau_n}}{\down{\tau_r}} \\
- \down{\TApp{C}{\tau_0, \ldots, \tau_n}} & = & \TApp{C}{\down{\tau_0}, \ldots, \down{\tau_n}} \\
- \down{\tau} & = & \tau\ \mbox{otherwise}
-\end{eqnarray*}
-
-\begin{eqnarray*}
- \up{T} & = & \Dynamic \\
- \up{\Arrow[k]{\tau_0, \ldots, \tau_n}{\tau_r}} & = &
- \Arrow[k]{\down{\tau_0}, \ldots, \down{\tau_n}}{\up{\tau_r}} \\
- \up{\TApp{C}{\tau_0, \ldots, \tau_n}} & = & \TApp{C}{\up{\tau_0}, \ldots, \up{\tau_n}} \\
- \up{\tau} & = & \tau\ \mbox{if $\tau$ is base type.}
-\end{eqnarray*}
-
-
-}
-\subsection*{Expression typing: $\yieldsOk{\Phi, \Delta, \Gamma}{e}{\opt{\tau}}{e'}{\tau'}$}
-\hrulefill\\
-
-
-\sstext{ Expression typing is a relation between typing contexts, a term ($e$),
- an optional type ($\opt{\tau}$), and a type ($\tau'$). The general idea is
- that we are typechecking a term ($e$) and want to know if it is well-typed.
- The term appears in a context, which may (or may not) impose a type constraint
- on the term. For example, in $\dvar{x:\tau}{e}$, $e$ appears in a context
- which requires it to be a subtype of $\tau$, or to be coercable to $\tau$.
- Alternatively if $e$ appears as in $\dvar{x:\_}{e}$, then the context does not
- provide a type constraint on $e$. This ``contextual'' type information is
- both a constraint on the term, and may also provide a source of information
- for type inference in $e$. The optional type $\opt{\tau}$ in the typing
- relation corresponds to this contextual type information. Viewing the
- relation algorithmically, this should be viewed as an input to the algorithm,
- along with the term. The process of checking a term allows us to synthesize a
- precise type for the term $e$ which may be more precise than the type required
- by the context. The type $\tau'$ in the relation represents this more
- precise, synthesized type. This type should be thought of as an output of the
- algorithm. It should always be the case that the synthesized (output) type is
- a subtype of the checked (input) type if the latter is present. The
- checking/synthesis pattern allows for the propagation of type information both
- downwards and upwards.
-
- It is often the case that downwards propagation is not useful. Consequently,
- to simplify the presentation the rules which do not use the checking type
- require that it be empty ($\_$). This does not mean that such terms cannot be
- checked when contextual type information is supplied: the first typing rule
- allows contextual type information to be dropped so that such rules apply in
- the case that we have contextual type information, subject to the contextual
- type being a supertype of the synthesized type:
-
-}{
-For subsumption, the elaboration of the underlying term carries through.
-}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}{e}{\_}{e'}{\sigma} \quad\quad
- \subtypeOf{\Phi, \Delta}{\sigma}{\tau}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}{e}{\tau}{e'}{\sigma}}
-
-\sstext{
-The implicit downcast rule also allows this when the contextual type is a
-subtype of the synthesized type, corresponding to an implicit downcast.
-}{
-In an implicit downcast, the elaboration adds a check so that an error
-will be thrown if the types do not match at runtime.
-}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}{e}{\_}{e'}{\sigma} \quad\quad
- \subtypeOf{\Phi, \Delta}{\tau}{\sigma}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}{e}{\tau}{\echeck{e'}{\tau}}{\tau}}
-
-\sstext{Variables are typed according to their declarations:}{}
-
-\axiom{\yieldsOk{\Phi, \Delta, \extends{\Gamma}{x}{\tau}}{x}{\_}{x}{\tau}}
-
-\sstext{Numbers, booleans, and null all have a fixed synthesized type.}{}
-
-\axiom{\yieldsOk{\Phi, \Delta, \Gamma}{i}{\_}{i}{\Num}}
-
-\axiom{\yieldsOk{\Phi, \Delta, \Gamma}{\eff}{\_}{\eff}{\Bool}}
-
-\axiom{\yieldsOk{\Phi, \Delta, \Gamma}{\ett}{\_}{\ett}{\Bool}}
-
-\axiom{\yieldsOk{\Phi, \Delta, \Gamma}{\enull}{\_}{\enull}{\Bottom}}
-
-\sstext{A $\ethis$ expression is well-typed if we are inside of a method, and $\sigma$
-is the type of the enclosing class.}{}
-
-\infrule{\Gamma = \Gamma'_{\sigma}
- }
- {
- \yieldsOk{\Phi, \Delta, \Gamma}{\ethis}{\_}{\ethis}{\sigma}
- }
-
-\sstext{A fully annotated function is well-typed if its body is well-typed at its
-declared return type, under the assumption that the variables have their
-declared types.
-}{
-
-A fully annotated function elaborates to a function with an elaborated body.
-The rest of the function elaboration rules fill in the reified type using
-contextual information if present and applicable, or $\Dynamic$ otherwise.
-
-}
-
-\infrule{\Gamma' = \extends{\Gamma}{\many{x}}{\many{\tau}} \quad\quad
- \stmtOk{\Phi, \Delta, \Gamma'}{s}{\sigma}{s'}{\Gamma'}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\elambda{\many{x:\tau}}{\sigma}{s}}
- {\_}
- {\elambda{\many{x:\tau}}{\sigma}{s'}}
- {\Arrow[-]{\many{\tau}}{\sigma}}
- }
-
-\sstext{A function with a missing argument type is well-typed if it is well-typed with
-the argument type replaced with $\Dynamic$.}
-{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}
- {\elambda{x_0:\opt{\tau_0}, \ldots, x_i:\Dynamic, \ldots, x_n:\opt{\tau_n}}{\opt{\sigma}}{s}}
- {\opt{\tau}}
- {e_f}
- {\tau_f}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\elambda{x_0:\opt{\tau_0}, \ldots, x_i:\_, \ldots, x_n:\opt{\tau_n}}{\opt{\sigma}}{s}}
- {\opt{\tau}}
- {e_f}
- {\tau_f}
- }
-
-\sstext{A function with a missing argument type is well-typed if it is well-typed with
-the argument type replaced with the corresponding argument type from the context
-type. Note that this rule overlaps with the previous: the formal presentation
-leaves this as a non-deterministic choice.}{}
-
-\infrule{\tau_c = \Arrow[k]{\upsilon_0, \ldots, \upsilon_n}{\upsilon_r} \\
- \yieldsOk{\Phi, \Delta, \Gamma}
- {\elambda{x_0:\opt{\tau_0}, \ldots, x_i:\upsilon_i, \ldots, x_n:\opt{\tau_n}}{\opt{\sigma}}{s}}
- {\tau_c}
- {e_f}
- {\tau_f}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\elambda{x_0:\opt{\tau_0}, \ldots, x_i:\_, \ldots, x_n:\opt{\tau_n}}{\opt{\sigma}}{s}}
- {\tau_c}
- {e_f}
- {\tau_f}
- }
-
-\sstext{A function with a missing return type is well-typed if it is well-typed with
-the return type replaced with $\Dynamic$.}{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}
- {\elambda{\many{x:\opt{\tau}}}{\Dynamic}{s}}
- {\opt{\tau_c}}
- {e_f}
- {\tau_f}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\elambda{\many{x:\opt{\tau}}}{\_}{s}}
- {\opt{\tau_c}}
- {e_f}
- {\tau_f}
- }
-
-\sstext{A function with a missing return type is well-typed if it is well-typed with
-the return type replaced with the corresponding return type from the context
-type. Note that this rule overlaps with the previous: the formal presentation
-leaves this as a non-deterministic choice. }{}
-
-\infrule{\tau_c = \Arrow[k]{\upsilon_0, \ldots, \upsilon_n}{\upsilon_r} \\
- \yieldsOk{\Phi, \Delta, \Gamma}
- {\elambda{\many{x:\opt{\tau}}}{\upsilon_r}{s}}
- {\tau_c}
- {e_f}
- {\tau_f}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\elambda{\many{x:\opt{\tau}}}{\_}{s}}
- {\tau_c}
- {e_f}
- {\tau_f}
- }
-
-
-\sstext{Instance creation creates an instance of the appropriate type.}{}
-
-% FIXME(leafp): inference
-% FIXME(leafp): deal with bounds
-\infrule{(C : \dclass{\TApp{C}{T_0,\ldots,T_n}}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{\ldots}) \in \Phi \\
- \mbox{len}(\many{\tau}) = n+1}
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\enew{C}{\many{\tau}}{}}
- {\_}
- {\enew{C}{\many{\tau}}{}}
- {\TApp{C}{\many{\tau}}}
- }
-
-
-\sstext{Members of the set of primitive operations (left unspecified) can only be
-applied. Applications of primitives are well-typed if the arguments are
-well-typed at the types given by the signature of the primitive.}{}
-
-\infrule{\eprim\, :\, \Arrow[]{\many{\tau}}{\sigma} \quad\quad
- \yieldsOk{\Phi, \Delta, \Gamma}{e}{\tau}{e'}{\tau'}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\eprimapp{\eprim}{\many{e}}}
- {\_}
- {\eprimapp{\eprim}{\many{e'}}}
- {\sigma}
- }
-
-\sstext{Function applications are well-typed if the applicand is well-typed and has
-function type, and the arguments are well-typed.}
-{
-
-Function application of an expression of function type elaborates to either a
-call or a dynamic (checked) call, depending on the variance of the applicand.
-If the applicand is a covariant (fuzzy) type, then a dynamic call is generated.
-
-}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}
- {e}
- {\_}
- {e'}
- {\Arrow[k]{\many{\tau_a}}{\tau_r}} \\
- \yieldsOk{\Phi, \Delta, \Gamma}
- {e_a}
- {\tau_a}
- {e_a'}
- {\tau_a'} \quad \mbox{for}\ e_a, \tau_a \in \many{e_a}, \many{\tau_a}
-\iftrans{\\ e_c = \begin{cases}
- \ecall{e'}{\many{e_a'}} & \text{if $k = -$}\\
- \edcall{e'}{\many{e_a'}} & \text{if $k = +$}
- \end{cases}}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\ecall{e}{\many{e_a}}}
- {\_}
- {e_c}
- {\tau_r}
- }
-
-\sstext{Application of an expression of type $\Dynamic$ is well-typed if the arguments
-are well-typed at any type. }
-{
-
- Application of an expression of type $\Dynamic$ elaborates to a dynamic call.
-
-}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}
- {e}
- {\_}
- {e'}
- {\Dynamic} \\
- \yieldsOk{\Phi, \Delta, \Gamma}
- {e_a}
- {\_}
- {e_a'}
- {\tau_a'} \quad \mbox{for}\ e_a \in \many{e_a}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\ecall{e}{\many{e_a}}}
- {\_}
- {\edcall{e'}{\many{e_a'}}}
- {\Dynamic}
- }
-
-\iftrans{
-\sstext{A dynamic call expression is well-typed so long as the applicand and the
-arguments are well-typed at any type.}{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}
- {e}
- {\Dynamic}
- {e'}
- {\tau} \\
- \yieldsOk{\Phi, \Delta, \Gamma}
- {e_a}
- {\_}
- {e_a'}
- {\tau_a} \quad \mbox{for}\ e_a \in \many{e_a}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\edcall{e}{\many{e_a}}}
- {\_}
- {\edcall{e'}{\many{e_a'}}}
- {\Dynamic}
- }
-
-}
-
-\sstext{A method load is well-typed if the term is well-typed, and the method name is
-present in the type of the term.}{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}
- {e}
- {\_}
- {e'}
- {\sigma} \quad\quad
- \methodLookup{\Phi}{\sigma}{m}{\sigma}{\tau}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\eload{e}{m}}
- {\_}
- {\eload{e'}{m}}
- {\tau}
- }
-
-\sstext{A method load from a term of type $\Dynamic$ is well-typed if the term is
-well-typed.}
-{
-
- A method load from a term of type $\Dynamic$ elaborates to a dynamic (checked)
- load.
-
-}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}
- {e}
- {\Dynamic}
- {e'}
- {\tau}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\eload{e}{m}}
- {\_}
- {\edload{e'}{m}}
- {\Dynamic}
- }
-
-\iftrans{
-\sstext{A dynamic method load is well typed so long as the term is well-typed.}{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}
- {e}
- {\Dynamic}
- {e'}
- {\tau}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\edload{e}{m}}
- {\_}
- {\edload{e'}{m}}
- {\Dynamic}
- }
-
-}
-
-\sstext{A field load from $\ethis$ is well-typed if the field name is present in the
-type of $\ethis$.}{}
-
-\infrule{\Gamma = \Gamma_\tau & \fieldLookup{\Phi}{\tau}{x}{\sigma}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\eload{\ethis}{x}}
- {\_}
- {\eload{\ethis}{x}}
- {\sigma}
- }
-
-\sstext{An assignment expression is well-typed so long as the term is well-typed at a
-type which is compatible with the type of the variable being assigned.}{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}
- {e}
- {\opt{\tau}}
- {e'}
- {\sigma} \quad\quad
- \yieldsOk{\Phi, \Delta, \Gamma}
- {x}
- {\sigma}
- {x}
- {\sigma'}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\eassign{x}{e}}
- {\opt{\tau}}
- {\eassign{x}{e'}}
- {\sigma}
- }
-
-\sstext{A field assignment is well-typed if the term being assigned is well-typed, the
-field name is present in the type of $\ethis$, and the declared type of the
-field is compatible with the type of the expression being assigned.}{}
-
-\infrule{\Gamma = \Gamma_\tau \quad\quad
- \yieldsOk{\Phi, \Delta, \Gamma}
- {e}
- {\opt{\tau}}
- {e'}
- {\sigma} \\
- \fieldLookup{\Phi}{\tau}{x}{\sigma'} \quad\quad
- \subtypeOf{\Phi, \Delta}{\sigma}{\sigma'}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\eset{\ethis}{x}{e}}
- {\_}
- {\eset{\ethis}{x}{e}}
- {\sigma}
- }
-
-\sstext{A throw expression is well-typed at any type.}{}
-
-\axiom{\yieldsOk{\Phi, \Delta, \Gamma}
- {\ethrow}
- {\_}
- {\ethrow}
- {\sigma}
- }
-
-\sstext{A cast expression is well-typed so long as the term being cast is well-typed.
-The synthesized type is the cast-to type. We require that the cast-to type be a
-ground type.}{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}{e}{\_}{e'}{\sigma} \quad\quad \mbox{$\tau$ is ground}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\eas{e}{\tau}}
- {\_}
- {\eas{e'}{\tau}}
- {\tau}
- }
-
-\sstext{An instance check expression is well-typed if the term being checked is
-well-typed. We require that the cast to-type be a ground type.}{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}{e}{\_}{e'}{\sigma} \quad\quad \mbox{$\tau$ is ground}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\eis{e}{\tau}}
- {\_}
- {\eis{e'}{\tau}}
- {\Bool}
- }
-
-\iftrans{
-
-\sstext{A check expression is well-typed so long as the term being checked is
-well-typed. The synthesized type is the target type of the check.}{}
-
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}{e}{\_}{e'}{\sigma}
- }
- {\yieldsOk{\Phi, \Delta, \Gamma}
- {\echeck{e}{\tau}}
- {\_}
- {\echeck{e'}{\tau}}
- {\tau}
- }
-
-}
-
-\subsection*{Declaration typing: $\declOk[d]{\Phi, \Delta, \Gamma}{\mathit{vd}}{\mathit{vd'}}{\Gamma'}$}
-\hrulefill\\
-
-\sstext{
-Variable declaration typing checks the well-formedness of the components, and
-produces an output context $\Gamma'$ which contains the binding introduced by
-the declaration.
-
-A simple variable declaration with a declared type is well-typed if the
-initializer for the declaration is well-typed at the declared type. The output
-context binds the variable at the declared type.
-}
-{
- Elaboration of declarations elaborates the underlying expressions.
-}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}{e}{\tau}{e'}{\tau'}
- }
- {\declOk[d]{\Phi, \Delta, \Gamma}
- {\dvar{x:\tau}{e}}
- {\dvar{x:\tau'}{e'}}
- {\extends{\Gamma}{x}{\tau}}
- }
-
-\sstext{A simple variable declaration without a declared type is well-typed if the
-initializer for the declaration is well-typed at any type. The output context
-binds the variable at the synthesized type (a simple form of type inference).}{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}{e}{\_}{e'}{\tau'}
- }
- {\declOk[d]{\Phi, \Delta, \Gamma}
- {\dvar{x:\_}{e}}
- {\dvar{x:\tau'}{e'}}
- {\extends{\Gamma}{x}{\tau'}}
- }
-
-\sstext{A function declaration is well-typed if the body of the function is well-typed
-with the given return type, under the assumption that the function and its
-parameters have their declared types. The function is assumed to have a
-contravariant (precise) function type. The output context binds the function
-variable only.}{}
-
-\infrule{\tau_f = \Arrow[-]{\many{\tau_a}}{\tau_r} \quad\quad
- \Gamma' = \extends{\Gamma}{f}{\tau_f} \quad\quad
- \Gamma'' = \extends{\Gamma'}{\many{x}}{\many{\tau_a}} \\
- \stmtOk{\Phi, \Delta, \Gamma''}{s}{\tau_r}{s'}{\Gamma_0}
- }
- {\declOk[d]{\Phi, \Delta, \Gamma}
- {\dfun{\tau_r}{f}{\many{x:\tau_a}}{s}}
- {\dfun{\tau_r}{f}{\many{x:\tau_a}}{s'}}
- {\Gamma'}
- }
-
-\subsection*{Statement typing: $\stmtOk{\Phi, \Delta, \Gamma}{\mathit{s}}{\tau}{\mathit{s'}}{\Gamma'}$}
-\hrulefill\\
-
-\sstext{The statement typing relation checks the well-formedness of statements and
-produces an output context which reflects any additional variable bindings
-introduced into scope by the statements.
-}{
-
-Statement elaboration elaborates the underlying expressions.
-
-}
-
-\sstext{A variable declaration statement is well-typed if the variable declaration is
-well-typed per the previous relation, with the corresponding output context.
-}{}
-
-\infrule{\declOk[d]{\Phi, \Delta, \Gamma}
- {\mathit{vd}}
- {\mathit{vd'}}
- {\Gamma'}
- }
- {\stmtOk{\Phi, \Delta, \Gamma}
- {\mathit{vd}}
- {\tau}
- {\mathit{vd'}}
- {\Gamma'}
- }
-
-\sstext{An expression statement is well-typed if the expression is well-typed at any
-type per the expression typing relation.}{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}{e}{\_}{e'}{\tau}
- }
- {\stmtOk{\Phi, \Delta, \Gamma}{e}{\tau}{e'}{\Gamma}
- }
-
-\sstext{A conditional statement is well-typed if the condition is well-typed as a
-boolean, and the statements making up the two arms are well-typed. The output
-context is unchanged.}{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}{e}{\Bool}{e'}{\sigma} \\
- \stmtOk{\Phi, \Delta, \Gamma}{s_1}{\tau_r}{s_1'}{\Gamma_1} \quad\quad
- \stmtOk{\Phi, \Delta, \Gamma}{s_2}{\tau_r}{s_2'}{\Gamma_2}
- }
- {\stmtOk{\Phi, \Delta, \Gamma}
- {\sifthenelse{e}{s_1}{s_2}}
- {\tau_r}
- {\sifthenelse{e'}{s_1'}{s_2'}}
- {\Gamma}
- }
-
-\sstext{A return statement is well-typed if the expression being returned is well-typed
-at the given return type. }{}
-
-\infrule{\yieldsOk{\Phi, \Delta, \Gamma}{e}{\tau_r}{e'}{\tau}
- }
- {\stmtOk{\Phi, \Delta, \Gamma}{\sreturn{e}}{\tau_r}{\sreturn{e'}}{\Gamma}
- }
-
-\sstext{A sequence statement is well-typed if the first component is well-typed, and the
-second component is well-typed with the output context of the first component as
-its input context. The final output context is the output context of the second
-component.}{}
-
-\infrule{\stmtOk{\Phi, \Delta, \Gamma}{s_1}{\tau_r}{s_1'}{\Gamma'} \quad\quad
- \stmtOk{\Phi, \Delta, \Gamma'}{s_2}{\tau_r}{s_2'}{\Gamma''}
- }
- {\stmtOk{\Phi, \Delta, \Gamma}{s_1;s_2}{\tau_r}{s_1';s_2'}{\Gamma''}
- }
-
-\subsection*{Class member typing: $\declOk[ce]{\Phi, \Delta, \Gamma}{\mathit{vd} : \mathit{ce}}{\mathit{vd}'}{\Gamma'}$}
-\hrulefill\\
-
-\sstext{
-
-A class member is well-typed with a given signature ($\mathit{ce}$) taken from
-the class hierarchy if the signature type matches the type on the definition,
-and if the definition is well-typed.
-
-}
-{
-
-Elaborating class members is done with respect to a signature. The field
-translation simply translates the field as a variable declaration.
-
-}
-
-
-\infrule{
- \declOk[d]{\Phi, \Delta, \Gamma}
- {\dvar{x:\opt{\tau}}{e}}
- {\mathit{vd'}}
- {\Gamma'}
- }
- {
- \declOk[ce]{\Phi, \Delta, \Gamma}
- {\dvar{x:\opt{\tau}}{e} : \fieldDecl{x}{\opt{\tau}}}
- {\mathit{vd'}}
- {\Gamma'}
- }
-
-
-\iftrans{
-
-Translating methods requires introducing guard expressions. The signature
-provides an internal and an external type for the method. The external type is
-the original declared type of the method, and is the signature which the method
-presents to external clients. Because we implement covariant generics, clients
-may see an instantiation of this signature which will allow them to violate the
-contract expected by the implementation. To handle this, we rewrite the method
-to match an internal signature which is in fact soundly covariant in the type
-parameters (that is, all contravariant type parameters are replaced with
-$\Dynamic$, and hence all remaining type parameters occur in properly covariant
-positions). This property is enforced in the override checking relation: from
-the perspective of this relation, there is simply another internal type which
-defines how to wrap the method with guards.
-
-The translation insists that the internal and external types be function types
-of the appropriate arity, and that the external type is equal to the type of the
-declaration. The declaration is translated using the underlying function
-definition translation, but is then wrapped with guards to enforce the type
-contract, producing a valid function of the internal (covariant) type. The
-original body of the function is wrapped in a lambda function, which is applied
-using a dynamic call which checks that the arguments (which may have negative
-occurrences of type variables which are treated as $\Dynamic$ in the internal
-type) are appropriate for the actual body. The original function returns a type
-$\tau_r$ which may be a super-type of the internal type (since negative
-occurrences of type variables must be treated as dynamic), and so we insert a
-check expression to guard against runtime type mismatches here.
-
-This is a very simplistic translation for now. We could choose, in the case
-that the body returns a lambda, to push the checking down into the lambda
-(essentially wrapping it in place).
-
-}
-
-\infrule{ \mathit{vd} = \dfun{\tau_r}{f}{x_0:\tau_0, \ldots, x_n:\tau_n}{s} \\
- \sigma_e = \Arrow[+]{\tau_0, \ldots, \tau_n}{\tau_r}
-\iftrans{\quad\quad
- \sigma_i = \Arrow{\upsilon_0, \ldots, \upsilon_n}{\upsilon_r}
-} \\
- \declOk[d]{\Phi, \Delta, \Gamma}
- {\mathit{vd}}
- {\dfun{\tau_r}{f}{x_0:\tau_0, \ldots, x_n:\tau_n}{s'}}
- {\Gamma'}
-\iftrans{\\
- e_g = \elambda{x_0:\tau_0, \ldots, x_n:\tau_n}{\tau_r}{s'}\\
- s_g = \sreturn{(\echeck{\edcall{e_g}{x_0 , \ldots, x_n}}{\upsilon_r})} \\
- \mathit{vd}_g = \dfun{\upsilon_r}{f}{x_0:\upsilon_0, \ldots, x_n:\upsilon_n}{s_g}
-}
- }
- {
- \declOk[ce]{\Phi, \Delta, \Gamma}
- {\mathit{vd} : \methodDecl{f}{\sigma_i}{\sigma_e}}
- {\mathit{vd}_g}
- {\Gamma'}
- }
-
-\subsection*{Class declaration typing: $\declOk[c]{\Phi, \Gamma}{\mathit{cd}}{\mathit{cd'}}{\Gamma'}$}
-\hrulefill\\
-
-\sstext{
-
-A class declaration is well-typed with a given signature ($\Sig$) taken from the
-class hierarchy if the signature matches the definition, and if each member of
-the class is well-typed with the corresponding signature from the class
-signature. The members are checked with the generic type parameters bound in
-the type context, and with the type of the current class set as the type of
-$\ethis$ on the term context $\Gamma$.
-
-}
-{
-
-Elaboration of a class requires that the class hierarchy $\Phi$ have a matching
-signature for the class declaration. Each class member in the class is
-elaborated using the corresponding class element from the signature.
-
-}
-
-
-\infrule{\mathit{cd} = \dclass{\TApp{C}{\many{T}}}{\TApp{G}{\many{\tau}}}{\mathit{vd}_0, \ldots, \mathit{vd}_n} \\
- (C : \dclass{\TApp{C}{\many{T}}}{\TApp{G}{\many{\tau}}}{\mathit{ce}_0, \ldots, \many{ce}_n}) \in \Phi \\
- \Delta = \many{T} \quad
- \Gamma_i =
- \begin{cases}
- \Gamma_{\TApp{C}{\many{T}}} & \mbox{if $\mathit{vd}_i$ is a method} \\
- \Gamma & \mbox{if $\mathit{vd}_i$ is a field} \\
- \end{cases}\\
-
- \declOk[ce]{\Phi, \Delta, \Gamma_i}{\mathit{vd}_i : \mathit{ce}_i}{\mathit{vd}'_i}{\Gamma'_i} \quad\quad
- \mbox{for}\ i \in 0, \ldots, n
-\iftrans{\\
- \mathit{cd'} = \dclass{\TApp{C}{\many{T}}}{\TApp{G}{\many{\tau}}}{\many{\mathit{vd'}}}
-}
- }
- {\declOk[c]{\Phi, \Gamma}
- {\mathit{cd}}
- {\mathit{cd'}}{\Gamma'}
- }
-
-\subsection*{Override checking:\\ \quad\quad$\overrideOk{\Phi}
- {\TApp{C}{T_0, \ldots, T_n}}
- {\TApp{G}{\tau_0, \ldots, \tau_k}}
- {\mathit{ce}}$}
-\hrulefill\\
-
-\sstext{
-
-The override checking relation is the primary relation that checks the
-consistency of the class hierarchy. We assume a non-cyclic class hierarchy as a
-syntactic pre-condition. The override check relation checks that in a class
-declaration $\TApp{C}{T_0, \ldots, T_n}$ which extends $\TApp{G}{\tau_0, \ldots,
- \tau_k}$, the definition of an element with signature $\mathit{ce}$ is valid.
-
-}{
-
-Override checking remains largely the same, with the exception of additional
-consistency constraints on the internal signatures for methods.
-
-}
-
-\sstext{
-
-A field with the type elided is a valid override if the same field with type
-$\Dynamic$ is valid.
-
-}{
-
-}
-
-\infrule{
- \overrideOk{\Phi}
- {\TApp{C}{T_0, \ldots, T_n}}
- {\TApp{G}{\tau_0, \ldots, \tau_k}}
- {\fieldDecl{x}{\Dynamic}}
-
- }
- {
- \overrideOk{\Phi}
- {\TApp{C}{T_0, \ldots, T_n}}
- {\TApp{G}{\tau_0, \ldots, \tau_k}}
- {\fieldDecl{x}{\_}}
- }
-
-\sstext{
-
-A field with a type $\tau$ is a valid override if it appears in the super type
-with the same type.
-
-}{
-
-}
-
-\infrule{\fieldLookup{\Phi}{\TApp{G}{\tau_0, \ldots, \tau_k}}{x}{\tau}
- }
- {
- \overrideOk{\Phi}
- {\TApp{C}{T_0, \ldots, T_n}}
- {\TApp{G}{\tau_0, \ldots, \tau_k}}
- {\fieldDecl{x}{\tau}}
- }
-
-\sstext{
-
-A field with a type $\tau$ is a valid override if it does not appear in the super type.
-
-}{
-
-}
-
-\infrule{\fieldAbsent{\Phi}{\TApp{G}{\tau_0, \ldots, \tau_k}}{x}
- }
- {
- \overrideOk{\Phi}
- {\TApp{C}{T_0, \ldots, T_n}}
- {\TApp{G}{\tau_0, \ldots, \tau_k}}
- {\fieldDecl{x}{\tau}}
- }
-
-\sstext{
-
-A method with a type $\sigma$ is a valid override if it does not appear in the super type.
-
-}{
-
-For a non-override method, we require that the internal type $\tau$ be a subtype
-of $\down{\sigma}$ where $\sigma$ is the declared type. Essentially, this
-enforces the property that the initial declaration of a method in the hierarchy
-has a covariant internal type.
-
-}
-
-\infrule{
-\iftrans{
- \Delta = T_0, \ldots, T_n \quad\quad
- \subtypeOf{\Phi, \Delta}{\tau}{\down{\sigma}}\ \\
-}
- \methodAbsent{\Phi}{\TApp{G}{\tau_0, \ldots, \tau_k}}{f}
- }
- {
- \overrideOk{\Phi}
- {\TApp{C}{T_0, \ldots, T_n}}
- {\TApp{G}{\tau_0, \ldots, \tau_k}}
- {\methodDecl{f}{\tau}{\sigma}}
- }
-
-\sstext{
-
-A method with a type $\sigma$ is a valid override if it appears in the super
-type, and $\sigma$ is a subtype of the type of the method in the super class.
-
-}{
-
-For a method override, we require two coherence conditions. As before, we
-require that the internal type $\tau$ be a subtype of the $\down{\sigma}$ where
-$\sigma$ is the external type. Moreover, we also insist that the external type
-$\sigma$ be a subtype of the external type of the method in the superclass, and
-that the internal type $\tau$ be a subtype of the internal type in the
-superclass. Note that it this last consistency property that ensures that
-covariant generics are ``poisonous'' in the sense that non-generic subclasses of
-generic classes must still have additional checks. For example, a superclass
-with a method of external type $\sigma_s = \Arrow{T}{T}$ will have internal type
-$\tau_s = \Arrow{\Dynamic}{T}$. A subclass of an instantiation of this class
-with $\Num$ can validly override this method with one of external type $\sigma =
-\Arrow{\Num}{\Num}$. This is unsound in general since the argument occurrence
-of $T$ in $\sigma_s$ is contra-variant. However, the additional consistency
-requirement is that the internal type of the subclass method must be a subtype
-of $\subst{\Num}{T}{\tau_s} = \Arrow{\Dynamic}{\Num}$. This enforces the
-property that the overridden method must expect to be used at type
-$\Arrow{\Dynamic}{\Num}$, and hence must check its arguments (and potentially
-its return value as well in the higher-order case). This checking code is
-inserted during the elaboration of class members above.
-
- }
-
-\infrule{
-\iftrans{
- \Delta = T_0, \ldots, T_n \quad\quad
- \subtypeOf{\Phi, \Delta}{\tau}{\down{\sigma}}\ \\
-}
- \methodLookup{\Phi}{\TApp{G}{\tau_0, \ldots, \tau_k}}{f}{\tau_s}{\sigma_s} \\
-\iftrans{
- \subtypeOf{\Phi, \Delta}{\tau}{\tau_s}\quad\quad
-}
- \subtypeOf{\Phi, \Delta}{\sigma}{\sigma_s}
- }
- {
- \overrideOk{\Phi}
- {\TApp{C}{T_0, \ldots, T_n}}
- {\TApp{G}{\tau_0, \ldots, \tau_k}}
- {\methodDecl{f}{\tau}{\sigma}}
- }
-
-\subsection*{Toplevel declaration typing: $\declOk[t]{\Phi, \Gamma}{\mathit{td}}{\mathit{td'}}{\Gamma'}$}
-\hrulefill\\
-
-\sstext{
-
-Top level variable declarations are well-typed if they are well-typed according
-to their respective specific typing relations.
-
-}{
-
-Top level declaration elaboration falls through to the underlying variable and
-class declaration code.
-
-}
-
-\infrule
- {\declOk[d]{\Phi, \epsilon, \Gamma}{\mathit{vd}}{\mathit{vd'}}{\Gamma'}
-
- }
- {\declOk[t]{\Phi, \Gamma}{\mathit{vd}}{\mathit{vd'}}{\Gamma'}
- }
-
-\infrule
- {\declOk[c]{\Phi, \Gamma}{\mathit{cd}}{\mathit{cd'}}{\Gamma'}
-
- }
- {\declOk[t]{\Phi, \Gamma}{\mathit{cd}}{\mathit{cd'}}{\Gamma'}
- }
-
-
-\subsection*{Well-formed class signature: $\ok{\Phi}{\Sig}$}
-\hrulefill\\
-
-\sstext{
-
-The well-formed class signature relation checks whether a class signature is
-well-formed with respect to a given class hierarchy $\Phi$.
-
-}{
-
-}
-
-\sstext{
-
-The $\Object$ signature is always well-formed.
-
-}{
-
-}
-
-\axiom{\ok{\Phi}{\Object}
- }
-
-\sstext{
-
-A signature for a class $C$ is well-formed if its super-class signature is
-well-formed, and if every element in its signature is a valid override of the
-super-class.
-
-}{
-
-}
-
-\infrule{\Sig = \dclass{\TApp{C}{\many{T}}}
- {\TApp{G}{\tau_0, \ldots, \tau_k}}
- {\mathit{ce}_0, \ldots, \mathit{ce}_n} \\
- (G : \Sig') \in \Phi \quad\quad \ok{\Phi}{\Sig'} \\
- \overrideOk{\Phi}{\TApp{C}{\many{T}}}{\TApp{G}{\tau_0, \ldots, \tau_k}}{\mathit{ce}_i}
- \quad\quad
- \mbox{for}\ \mathit{ce}_i \in \mathit{ce}_0, \ldots, \mathit{ce}_n
- }
- {\ok{\Phi}{\Sig}
- }
-
-\subsection*{Well-formed class hierarchy: $\ok{}{\Phi}$}
-\hrulefill\\
-
-\sstext{
-
-A class hierarchy is well-formed if all of the signatures in it are well-formed
-with respect to it.
-
-}{
-
-}
-
-\infrule{\ok{\Phi}{\Sig}\ \mbox{for}\, \Sig\, \in \Phi
- }
- {\ok{}{\Phi}
- }
-
-\subsection*{Program typing: $\programOk{\Phi}{P}{P'}$}
-\hrulefill\\
-
-%%Definitions:
-%%
-%% \begin{eqnarray*}
-%% \sigof{\mathit{vd}} & = &
-%% \begin{cases}
-%% \fieldDecl{x}{\tau} & \mbox{if}\ \mathit{vd} = \dvar{x:\tau}{e}\\
-%% \fieldDecl{x}{\Dynamic} & \mbox{if}\ \mathit{vd} = \dvar{x:\_}{e}\\
-%% \methodDecl{f}{\tau_f}{\Arrow[+]{\many{\tau}}{\sigma}} & \mbox{if}\ \mathit{vd} = \dfun{\sigma}{f}{\many{x:\tau}}{s}
-%% \end{cases}\\
-%% \sigof{\mathit{cd}} & = & C\, : \, \dclass{\TApp{C}{\many{T}}}
-%% {\TApp{G}{\tau_0, \ldots, \tau_k}}
-%% {\mathit{ce}_0, \ldots, \mathit{ce}_n} \\
-%% \mbox{where} &&
-%% \mathit{cd} = \dclass{\TApp{C}{\many{T}}}
-%% {\TApp{G}{\tau_0, \ldots, \tau_k}}
-%% {\mathit{vd}_0, \ldots, \mathit{vd}_n} \\
-%% \mbox{and} &&
-%% \mathit{ce}_i = \sigof{vd_i} \quad \mbox{for}\ i \in 0, \ldots, n
-%%\end{eqnarray*}
-
-\sstext{
-
-Program well-formedness is defined with respect to a class hierarchy $\Phi$. It
-is not specified how $\Phi$ is produced, but the well-formedness constraints in
-the various judgments should constrain it appropriately. A program is
-well-formed if each of the top level declarations in the program is well-formed
-in a context in which all of the previous variable declarations have been
-checked and inserted in the context, and if the body of the program is
-well-formed in the final context. We allow classes to refer to each other in
-any order, since $\Phi$ is pre-specified, but do not model out of order
-definitions of top level variables and functions. We assume as a syntactic
-property that the class hierarchy $\Phi$ is acyclic.
-
-}{
-
-}
-
-\infrule{ \Gamma_0 = \epsilon \quad\quad
- \declOk[t]{\Phi, \Gamma_i}{\mathit{td}_i}{\mathit{td}'_i}{\Gamma_{i+1}} \quad
- \mbox{for}\ i \in 0,\ldots,n\\
- \stmtOk{\Phi, \epsilon, \Gamma_{n+1}}{s}{\tau}{s'}{\Gamma_{n+1}'}
- }
- { \programOk{\Phi}{\program{\mathit{td}_0, \ldots, \mathit{td}_n}{s}}
- {\program{\mathit{td}'_0, \ldots, \mathit{td}'_n}{s'}}
- }
diff --git a/pkg/dev_compiler/doc/definition/strong-dart.pdf b/pkg/dev_compiler/doc/definition/strong-dart.pdf
deleted file mode 100644
index 1b58a47..0000000
--- a/pkg/dev_compiler/doc/definition/strong-dart.pdf
+++ /dev/null
Binary files differ
diff --git a/pkg/dev_compiler/doc/definition/strong-dart.tex b/pkg/dev_compiler/doc/definition/strong-dart.tex
deleted file mode 100644
index 216b476..0000000
--- a/pkg/dev_compiler/doc/definition/strong-dart.tex
+++ /dev/null
@@ -1,347 +0,0 @@
-\documentclass[fleqn, draft]{article}
-\usepackage{proof, amsmath, amssymb, ifthen}
-\input{macros.tex}
-
-% types
-\newcommand{\Arrow}[3][-]{#2 \overset{#1}{\rightarrow} #3}
-\newcommand{\Bool}{\mathbf{bool}}
-\newcommand{\Bottom}{\mathbf{bottom}}
-\newcommand{\Dynamic}{\mathbf{dynamic}}
-\newcommand{\Null}{\mathbf{Null}}
-\newcommand{\Num}{\mathbf{num}}
-\newcommand{\Object}{\mathbf{Object}}
-\newcommand{\TApp}[2]{#1\mathrm{<}#2\mathrm{>}}
-\newcommand{\Type}{\mathbf{Type}}
-\newcommand{\Weak}[1]{\mathbf{\{#1\}}}
-\newcommand{\Sig}{\mathit{Sig}}
-\newcommand{\Boxed}[1]{\langle #1 \rangle}
-
-% expressions
-\newcommand{\eassign}[2]{#1 = #2}
-\newcommand{\eas}[2]{#1\ \mathbf{as}\ #2}
-\newcommand{\ebox}[2]{\langle#1\rangle_{#2}}
-\newcommand{\ecall}[2]{#1(#2)}
-\newcommand{\echeck}[2]{\kwop{check}(#1, #2)}
-\newcommand{\edcall}[2]{\kwop{dcall}(#1, #2)}
-\newcommand{\edload}[2]{\kwop{dload}(#1, #2)}
-\newcommand{\edo}[1]{\kwdo\{\,#1\,\}}
-\newcommand{\eff}{\mathrm{ff}}
-\newcommand{\eis}[2]{#1\ \mathbf{is}\ #2}
-\newcommand{\elabel}[1][l]{\mathit{l}}
-\newcommand{\elambda}[3]{(#1):#2 \Rightarrow #3}
-\newcommand{\eload}[2]{#1.#2}
-\newcommand{\enew}[3]{\mathbf{new}\,\TApp{#1}{#2}(#3)}
-\newcommand{\enull}{\mathbf{null}}
-\newcommand{\eobject}[2]{\kwobject_{#1} \{#2\}}
-\newcommand{\eprimapp}[2]{\ecall{#1}{#2}}
-\newcommand{\eprim}{\kwop{op}}
-\newcommand{\esend}[3]{\ecall{\eload{#1}{#2}}{#3}}
-\newcommand{\eset}[3]{\eassign{#1.#2}{#3}}
-\newcommand{\esuper}{\mathbf{super}}
-\newcommand{\ethis}{\mathbf{this}}
-\newcommand{\ethrow}{\mathbf{throw}}
-\newcommand{\ett}{\mathrm{tt}}
-\newcommand{\eunbox}[1]{{*#1}}
-
-% keywords
-\newcommand{\kwclass}{\kw{class}}
-\newcommand{\kwdo}{\kw{do}}
-\newcommand{\kwelse}{\kw{else}}
-\newcommand{\kwextends}{\kw{extends}}
-\newcommand{\kwfun}{\kw{fun}}
-\newcommand{\kwif}{\kw{if}}
-\newcommand{\kwin}{\kw{in}}
-\newcommand{\kwlet}{\kw{let}}
-\newcommand{\kwobject}{\kw{object}}
-\newcommand{\kwreturn}{\kw{return}}
-\newcommand{\kwthen}{\kw{then}}
-\newcommand{\kwvar}{\kw{var}}
-
-% declarations
-\newcommand{\dclass}[3]{\kwclass\ #1\ \kwextends\ #2\ \{#3\}}
-\newcommand{\dfun}[4]{#2(#3):#1 = #4}
-\newcommand{\dvar}[2]{\kwvar\ #1\ =\ #2}
-
-
-\newcommand{\fieldDecl}[2]{\kwvar\ #1 : #2}
-\newcommand{\methodDecl}[3]{\kwfun\ #1 : \iftrans{#2 \triangleleft} #3}
-
-% statements
-\newcommand{\sifthenelse}[3]{\kwif\ (#1)\ \kwthen\ #2\ \kwelse\ #3}
-\newcommand{\sreturn}[1]{\kwreturn\ #1}
-
-% programs
-\newcommand{\program}[2]{\kwlet\ #1\ \kwin\ #2}
-
-% relational operators
-\newcommand{\sub}{\mathbin{<:}}
-
-% utilities
-\newcommand{\many}[1]{\overrightarrow{#1}}
-\newcommand{\alt}{\ \mathop{|}\ }
-\newcommand{\opt}[1]{[#1]}
-\newcommand{\bind}[3]{#1 \Leftarrow\, #2\ \kw{in}\ #3}
-
-\newcommand{\note}[1]{\textbf{NOTE:} \textit{#1}}
-
-%dynamic semantics
-\newcommand{\TypeError}{\mathbf{Error}}
-
-% inference rules
-\newcommand{\infrulem}[3][]{
- \begin{array}{c@{\ }c}
- \begin{array}{cccc}
- #2 \vspace{-2mm}
- \end{array} \\
- \hrulefill & #1 \\
- \begin{array}{l}
- #3
- \end{array}
- \end{array}
- }
-
-\newcommand{\axiomm}[2][]{
- \begin{array}{cc}
- \hrulefill & #1 \\
- \begin{array}{c}
- #2
- \end{array}
- \end{array}
- }
-
-\newcommand{\infrule}[3][]{
- \[
- \infrulem[#1]{#2}{#3}
- \]
- }
-
-\newcommand{\axiom}[2][]{
- \[
- \axiomm[#1]{#2}
- \]
- }
-
-% judgements and relations
-\newboolean{show_translation}
-\setboolean{show_translation}{false}
-\newcommand{\iftrans}[1]{\ifthenelse{\boolean{show_translation}}{#1}{}}
-\newcommand{\ifnottrans}[1]{\ifthenelse{\boolean{show_translation}}{#1}}
-
-\newcommand{\blockOk}[4]{#1 \vdash #2 \col #3\iftrans{\, \Uparrow\, #4}}
-\newcommand{\declOk}[5][]{#2 \vdash_{#1} #3 \, \Uparrow\, \iftrans{#4\, :\,} #5}
-\newcommand{\extends}[4][:]{#2[#3\ #1\ #4]}
-\newcommand{\fieldLookup}[4]{#1 \vdash #2.#3\, \leadsto_f\, #4}
-\newcommand{\methodLookup}[5]{#1 \vdash #2.#3\, \leadsto_m\, \iftrans{#4 \triangleleft} #5}
-\newcommand{\fieldAbsent}[3]{#1 \vdash #3 \notin #2}
-\newcommand{\methodAbsent}[3]{#1 \vdash #3 \notin #2}
-\newcommand{\hastype}[3]{#1 \vdash #2 \, : \, #3}
-\newcommand{\stmtOk}[5]{#1 \vdash #2 \, : \, #3\, \Uparrow \iftrans{#4\, :\,} #5}
-\newcommand{\subst}[2]{[#1/#2]}
-\newcommand{\subtypeOfOpt}[5][?]{#2 \vdash\ #3 \sub^{#1} #4\, \Uparrow\, #5}
-\newcommand{\subtypeOf}[4][]{#2 \vdash\ #3 \sub^{#1} #4}
-\newcommand{\yieldsOk}[5]{#1 \vdash #2 \, : \, #3\, \Uparrow\, \iftrans{#4\, :\,} #5}
-\newcommand{\programOk}[3]{#1 \vdash #2\iftrans{\, \Uparrow\, #3}}
-\newcommand{\ok}[2]{#1 \vdash #2\, \mbox{\textbf{ok}}}
-\newcommand{\overrideOk}[4]{#1 \vdash #2\,\kwextends\, #3 \Leftarrow\, #4}
-
-\newcommand{\down}[1]{\ensuremath{\downharpoonleft\!\!#1\!\!\downharpoonright}}
-\newcommand{\up}[1]{\ensuremath{\upharpoonleft\!\!#1\!\!\upharpoonright}}
-\newcommand{\sigof}[1]{\mathit{sigof}(#1)}
-\newcommand{\typeof}[1]{\mathit{typeof}(#1)}
-\newcommand{\sstext}[2]{\ifthenelse{\boolean{show_translation}}{#2}{#1}}
-
-\newcommand{\evaluatesTo}[5][]{\{#2\alt #3\} \stepsto_{#1} \{#4 \alt #5\}}
-
-
-\title{Dart strong mode definition}
-
-\begin{document}
-
-\textbf{\large PRELIMINARY DRAFT}
-
-\section*{Syntax}
-
-
-Terms and types. Note that we allow types to be optional in certain positions
-(currently function arguments and return types, and on variable declarations).
-Implicitly these are either inferred or filled in with dynamic.
-
-There are explicit terms for dynamic calls and loads, and for dynamic type
-checks.
-
-Fields can only be read or set within a method via a reference to this, so no
-dynamic set operation is required (essentially dynamic set becomes a dynamic
-call to a setter). This just simplifies the presentation a bit. Methods may be
-externally loaded from the object (either to call them, or to pass them as
-closurized functions).
-
-\[
-\begin{array}{lcl}
-\text{Type identifiers} & ::= & C, G, T, S, \ldots \\
-%
-\text{Arrow kind ($k$)} & ::= & +, -\\
-%
-\text{Types $\tau, \sigma$} & ::= &
- T \alt \Dynamic \alt \Object \alt \Null \alt \Type \alt \Num \\ &&
- \alt \Bool
- \alt \Arrow[k]{\many{\tau}}{\sigma} \alt \TApp{C}{\many{\tau}} \\
-%
-\text{Ground types $\tau, \sigma$} & ::= &
- \Dynamic \alt \Object \alt \Null \alt \Type \alt \Num \\ &&
- \alt \Bool
- \alt \Arrow[+]{\many{\Dynamic}}{\Dynamic} \alt \TApp{C}{\many{\Dynamic}} \\
-%
-\text{Optional type ($[\tau]$)} & ::= & \_ \alt \tau \\
-%
-\text{Term identifiers} & ::= & a, b, x, y, m, n, \ldots \\
-%
-\text{Primops ($\phi$)} & ::= & \mathrm{+}, \mathrm{-} \ldots \mathrm{||} \ldots \\
-%
-\text{Expressions $e$} & ::= &
- x \alt i \alt \ett \alt \eff \alt \enull \alt \ethis \\&&
- \alt \elambda{\many{x:\opt{\tau}}}{\opt{\sigma}}{s}
- \alt \enew{C}{\many{\tau}}{} \\&&
- \alt \eprimapp{\eprim}{\many{e}} \alt \ecall{e}{\many{e}} \\&&
- \alt \eload{e}{m} \alt \eload{\ethis}{x} \\&&
- \alt \eassign{x}{e} \alt \eset{\ethis}{x}{e} \\&&
- \alt \ethrow \alt \eas{e}{\tau} \alt \eis{e}{\tau} \\
-%
-\text{Declaration ($\mathit{vd}$)} & ::= &
- \dvar{x:\opt{\tau}}{e} \alt \dfun{\tau}{f}{\many{x:\tau}}{s} \\
-%
-\text{Statements ($s$)} & ::= & \mathit{vd} \alt e \alt \sifthenelse{e}{s_1}{s_2}
- \alt \sreturn{e} \alt s;s \\
-%
-\text{Class decl ($\mathit{cd}$)} & ::= & \dclass{\TApp{C}{\many{T}}}{\TApp{G}{\many{\tau}}}{\many{\mathit{vd}}} \\
-%
-\text{Toplevel decl ($\mathit{td}$)} & ::= & \mathit{vd} \alt \mathit{cd}\\
-%
-\text{Program ($P$)} & ::= & \program{\many{\mathit{td}}}{s}
-\end{array}
-\]
-
-
-Type contexts map type variables to their bounds.
-
-Class signatures describe the methods and fields in an object, along with the
-super class of the class. There are no static methods or fields.
-
-The class hierararchy records the classes with their signatures.
-
-The term context maps term variables to their types. I also abuse notation and
-allow for the attachment of an optional type to term contexts as follows:
-$\Gamma_\sigma$ refers to a term context within the body of a method whose class
-type is $\sigma$.
-
-\[
-\begin{array}{lcl}
-\text{Type context ($\Delta$)} & ::= & \epsilon \alt \Delta, T \sub \tau \\
-\text{Class element ($\mathit{ce}$)} & ::= &
- \fieldDecl{x}{\tau} \alt \methodDecl{f}{\tau}{\sigma} \\
-\text{Class signature ($\Sig$)} & ::= &
- \dclass{\TApp{C}{\many{T}}}{\TApp{G}{\many{\tau}}}{\many{\mathit{ce}}} \\
-\text{Class hierarchy ($\Phi$)} & ::= & \epsilon \alt \Phi, C\ :\ \Sig \\
-\text{Term context ($\Gamma$)} & ::= & \epsilon \alt \Gamma, x\ :\ \tau
-\end{array}
-\]
-
-
-\section*{Subtyping}
-
-\subsection*{Variant Subtyping}
-
-We include a special kind of covariant function space to model certain dart
-idioms. An arrow type decorated with a positive variance annotation ($+$)
-treats $\Dynamic$ in its argument list covariantly: or equivalently, it treats
-$\Dynamic$ as bottom. This variant subtyping relation captures this special
-treatment of dynamic.
-
-\axiom{\subtypeOf[+]{\Phi, \Delta}{\Dynamic}{\tau}}
-
-\infrule{\subtypeOf{\Phi, \Delta}{\sigma}{\tau} \quad \sigma \neq \Dynamic}
- {\subtypeOf[+]{\Phi, \Delta}{\sigma}{\tau}}
-
-\infrule{\subtypeOf{\Phi, \Delta}{\sigma}{\tau}}
- {\subtypeOf[-]{\Phi, \Delta}{\sigma}{\tau}}
-
-\subsection*{Invariant Subtyping}
-
-Regular subtyping is defined in a fairly standard way, except that generics are
-uniformly covariant, and that function argument types fall into the variant
-subtyping relation defined above.
-
-\axiom{\subtypeOf{\Phi, \Delta}{\tau}{\Dynamic}}
-
-\axiom{\subtypeOf{\Phi, \Delta}{\tau}{\Object}}
-
-\axiom{\subtypeOf{\Phi, \Delta}{\Bottom}{\tau}}
-
-\axiom{\subtypeOf{\Phi, \Delta}{\tau}{\tau}}
-
-\infrule{(S\, :\, \sigma) \in \Delta \quad
- \subtypeOf{\Phi, \Delta}{\sigma}{\tau}}
- {\subtypeOf{\Phi, \Delta}{S}{\tau}}
-
-\infrule{\subtypeOf[k_1]{\Phi, \Delta}{\sigma_i}{\tau_i} \quad i \in 0, \ldots, n \quad\quad
- \subtypeOf{\Phi, \Delta}{\tau_r}{\sigma_r} \\
- \quad (k_0 = \mbox{-}) \lor (k_1 = \mbox{+})
- }
- {\subtypeOf{\Phi, \Delta}
- {\Arrow[k_0]{\tau_0, \ldots, \tau_n}{\tau_r}}
- {\Arrow[k_1]{\sigma_0, \ldots, \sigma_n}{\sigma_r}}}
-
-\infrule{\subtypeOf{\Phi, \Delta}{\tau_i}{\sigma_i} & i \in 0, \ldots, n}
- {\subtypeOf{\Phi, \Delta}
- {\TApp{C}{\tau_0, \ldots, \tau_n}}
- {\TApp{C}{\sigma_0, \ldots, \sigma_n}}}
-
-\infrule{(C : \dclass{\TApp{C}{T_0,\ldots,T_n}}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}{\ldots}) \in \Phi \\
- \subtypeOf{\Phi, \Delta}{\subst{\tau_0, \ldots, \tau_n}{T_0, \ldots, T_n}{\TApp{C'}{\upsilon_0, \ldots, \upsilon_k}}}{\TApp{G}{\sigma_0, \ldots, \sigma_m}}}
- {\subtypeOf{\Phi, \Delta}
- {\TApp{C}{\tau_0, \ldots, \tau_n}}
- {\TApp{G}{\sigma_0, \ldots, \sigma_m}}}
-
-
-
-\section*{Typing}
-\input{static-semantics}
-
-\pagebreak
-\section*{Elaboration}
-\setboolean{show_translation}{true}
-
-Elaboration is a type driven translation which maps a source Dart term to a
-translated term which corresponds to the original term with additional dynamic
-type checks inserted to reify the static unsoundness as runtime type errors.
-For the translation, we extend the source language slightly as follows.
-\[
-\begin{array}{lcl}
-\text{Expressions $e$} & ::= & \ldots
- \alt \edcall{e}{\many{e}} \alt \edload{e}{m} \alt \echeck{e}{\tau}\\
-\end{array}
-\]
-
-The expression language is extended with an explicitly checked dynamic call
-operation, and explicitly checked dynamic method load operation, and a runtime
-type test. Note that while a user level cast throws an exception on failure,
-the runtime type test term introduced here produces a hard type error which
-cannot be caught programmatically.
-
-We also extend typing contexts slightly by adding an internal type to method signatures.
-\[
-\begin{array}{lcl}
-\text{Class element ($\mathit{ce}$)} & ::= &
- \fieldDecl{x}{\tau} \alt \methodDecl{f}{\tau}{\sigma} \\
-\end{array}
-\]
-A method signature of the form $\methodDecl{f}{\tau}{\sigma}$ describes a method
-whose public interface is described by $\sigma$, but which has an internal type
-$\tau$ which is a subtype of $\sigma$, but which is properly covariant in any
-type parameters. The elaboration introduces runtime type checks to mediate
-between the two types. This is discussed further in the translation of classes
-below.
-
-\input{static-semantics}
-
-
-\end{document}
diff --git a/pkg/front_end/benchmarks/patterns/test_lists_from_vs_of.dart b/pkg/front_end/benchmarks/patterns/test_lists_from_vs_of.dart
new file mode 100644
index 0000000..0ebf6da
--- /dev/null
+++ b/pkg/front_end/benchmarks/patterns/test_lists_from_vs_of.dart
@@ -0,0 +1,138 @@
+// Copyright (c) 2022, 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.
+
+import 'util.dart';
+
+typedef TestFunction<T> = List<T> Function(List<T>);
+
+class InputOutputData<T> {
+ final List<T> input;
+ final List<T> output;
+
+ const InputOutputData(this.input, this.output);
+}
+
+const Strategy fromStrategy = Strategy('from', '''
+Using List.from.''');
+
+const Strategy ofStrategy = Strategy('of', '''
+Using List.of.''');
+
+const Scenario emptyScenario = Scenario('empty', '''
+The input and output is empty.''');
+const Scenario oneEntryScenario = Scenario('one', '''
+The input is one entry.''');
+const Scenario severalEntriesScenario = Scenario('several', '''
+The input has several entries.''');
+
+Map<Scenario, InputOutputData<String>> scenarios = {
+ emptyScenario: const InputOutputData([], []),
+ oneEntryScenario: const InputOutputData(["a"], ["a"]),
+ severalEntriesScenario: const InputOutputData(
+ [
+ "a",
+ "b",
+ "c",
+ "d",
+ "e",
+ "f",
+ "g",
+ ],
+ [
+ "a",
+ "b",
+ "c",
+ "d",
+ "e",
+ "f",
+ "g",
+ ],
+ ),
+};
+
+class Test<T> {
+ final int size;
+ final Map<Strategy, TestFunction<T>> strategies;
+
+ const Test(this.size, this.strategies);
+
+ void _test(Registry registry, SeriesKey key, int runs, int iterations,
+ List<T> input, List<T> expectedResult, TestFunction<T> testFunction) {
+ for (int run = 0; run < runs; run++) {
+ Stopwatch sw = new Stopwatch();
+ for (int i = 0; i < iterations; i++) {
+ sw.start();
+ List<T> actualOutput = testFunction(input);
+ sw.stop();
+ checkEquals(actualOutput, expectedResult);
+ }
+ registry.registerData(key, size, sw.elapsedMicroseconds);
+ }
+ }
+
+ void checkEquals(List<T> a, List<T> b) {
+ if (a.length != b.length) throw "length for $a vs $b";
+ for (int i = 0; i < a.length; i++) {
+ if (a[i] != b[i]) throw "index $i for $a vs $b";
+ }
+ }
+
+ void performTest(
+ {required Registry registry,
+ required int runs,
+ required int iterations,
+ required Map<Scenario, InputOutputData<T>> scenarios}) {
+ for (MapEntry<Scenario, InputOutputData<T>> scenario in scenarios.entries) {
+ List<T> scenarioInput = scenario.value.input;
+ List<T> scenarioExpectedOutput = scenario.value.output;
+ for (MapEntry<Strategy, TestFunction<T>> entry in strategies.entries) {
+ _test(registry, new SeriesKey(entry.key, scenario.key), runs,
+ iterations, scenarioInput, scenarioExpectedOutput, entry.value);
+ }
+ }
+ }
+}
+
+List<Test<String>> tests = [
+ // "size" isn't used here...
+ Test<String>(-1, {
+ fromStrategy: from,
+ ofStrategy: of,
+ }),
+];
+
+List<String> from(List<String> input) {
+ return new List<String>.from(input);
+}
+
+List<String> of(List<String> input) {
+ return new List<String>.of(input);
+}
+
+void main() {
+ // Dry run
+ for (Test test in tests) {
+ test.performTest(
+ registry: new Registry(),
+ runs: 5,
+ iterations: 10,
+ scenarios: scenarios);
+ }
+ // Actual test
+ Registry registry = new Registry();
+ for (Test test in tests) {
+ test.performTest(
+ registry: registry, runs: 10, iterations: 200000, scenarios: scenarios);
+ }
+ SeriesSet seriesSet = registry.generateSeriesSet();
+ print('== Raw data ==');
+ for (Scenario scenario in scenarios.keys) {
+ print(seriesSet.getFullSpreadByScenario(scenario));
+ }
+ print('== Reduced averages ==');
+ SeriesSet reducedSeriesSet = seriesSet.filter((list) => removeMax(list, 3));
+ for (Scenario scenario in scenarios.keys) {
+ print(reducedSeriesSet.getAveragedSpreadByScenario(scenario));
+ }
+}
diff --git a/pkg/front_end/benchmarks/patterns/test_map_a_list.dart b/pkg/front_end/benchmarks/patterns/test_map_a_list.dart
new file mode 100644
index 0000000..d611a0e
--- /dev/null
+++ b/pkg/front_end/benchmarks/patterns/test_map_a_list.dart
@@ -0,0 +1,192 @@
+// Copyright (c) 2022, 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.
+
+import 'util.dart';
+
+typedef TestFunction<T, U> = List<U> Function(List<T>);
+
+class InputOutputData<T, U> {
+ final List<T> input;
+ final List<U> output;
+
+ const InputOutputData(this.input, this.output);
+}
+
+const Strategy simpleAddStrategy = Strategy('simple-add', '''
+Add entries to a list one at a time.''');
+
+const Strategy mapToListStrategy = Strategy('mapToList', '''
+Create the list via .map([...]).toList().''');
+
+const Strategy listGenerateGrowableStrategy =
+ Strategy('list-generate-growable', '''
+Create list via List.generate with growable = true.''');
+
+const Strategy listGenerateNotGrowableStrategy =
+ Strategy('list-generate-not-growable', '''
+Create list via List.generate with growable = false.''');
+
+const Strategy listFilledGrowableStrategy = Strategy('list-filled-growable', '''
+Create list via List.generate with growable = true.''');
+
+const Strategy listFilledNotGrowableStrategy =
+ Strategy('list-filled-not-growable', '''
+Create list via List.generate with growable = false.''');
+
+const Scenario emptyScenario = Scenario('empty', '''
+The input and output is empty.''');
+const Scenario oneEntryScenario = Scenario('one', '''
+The input is one entry.''');
+const Scenario severalEntriesScenario = Scenario('several', '''
+The input has several entries.''');
+
+class Input {
+ final String content;
+
+ const Input(this.content);
+}
+
+Map<Scenario, InputOutputData<Input, String>> scenarios = {
+ emptyScenario: const InputOutputData([], []),
+ oneEntryScenario: const InputOutputData([Input("a")], ["a"]),
+ severalEntriesScenario: const InputOutputData(
+ [
+ Input("a"),
+ Input("b"),
+ Input("c"),
+ Input("d"),
+ Input("e"),
+ Input("f"),
+ ],
+ [
+ "a",
+ "b",
+ "c",
+ "d",
+ "e",
+ "f",
+ ],
+ ),
+};
+
+class Test<T, U> {
+ final int size;
+ final Map<Strategy, TestFunction<T, U>> strategies;
+
+ const Test(this.size, this.strategies);
+
+ void _test(Registry registry, SeriesKey key, int runs, int iterations,
+ List<T> input, List<U> expectedResult, TestFunction<T, U> testFunction) {
+ for (int run = 0; run < runs; run++) {
+ Stopwatch sw = new Stopwatch();
+ for (int i = 0; i < iterations; i++) {
+ sw.start();
+ List<U> actualOutput = testFunction(input);
+ sw.stop();
+ checkEquals(actualOutput, expectedResult);
+ }
+ registry.registerData(key, size, sw.elapsedMicroseconds);
+ }
+ }
+
+ void checkEquals(List<U> a, List<U> b) {
+ if (a.length != b.length) throw "length for $a vs $b";
+ for (int i = 0; i < a.length; i++) {
+ if (a[i] != b[i]) throw "index $i for $a vs $b";
+ }
+ }
+
+ void performTest(
+ {required Registry registry,
+ required int runs,
+ required int iterations,
+ required Map<Scenario, InputOutputData<T, U>> scenarios}) {
+ for (MapEntry<Scenario, InputOutputData<T, U>> scenario
+ in scenarios.entries) {
+ List<T> scenarioInput = scenario.value.input;
+ List<U> scenarioExpectedOutput = scenario.value.output;
+ for (MapEntry<Strategy, TestFunction<T, U>> entry in strategies.entries) {
+ _test(registry, new SeriesKey(entry.key, scenario.key), runs,
+ iterations, scenarioInput, scenarioExpectedOutput, entry.value);
+ }
+ }
+ }
+}
+
+List<Test<Input, String>> tests = [
+ // "size" isn't used here...
+ Test<Input, String>(-1, {
+ simpleAddStrategy: simplyAdd,
+ listGenerateGrowableStrategy: listGenerateGrowable,
+ listGenerateNotGrowableStrategy: listGenerateNotGrowable,
+ listFilledGrowableStrategy: listFilledGrowable,
+ listFilledNotGrowableStrategy: listFilledNotGrowable,
+ mapToListStrategy: mapToList,
+ }),
+];
+
+List<String> simplyAdd(List<Input> input) {
+ List<String> result = [];
+ for (int i = 0; i < input.length; i++) {
+ result.add(input[i].content);
+ }
+ return result;
+}
+
+List<String> listGenerateGrowable(List<Input> input) {
+ return List<String>.generate(input.length, (index) => input[index].content,
+ growable: true);
+}
+
+List<String> listGenerateNotGrowable(List<Input> input) {
+ return List<String>.generate(input.length, (index) => input[index].content,
+ growable: false);
+}
+
+List<String> listFilledGrowable(List<Input> input) {
+ List<String> result = List<String>.filled(input.length, "", growable: true);
+ for (int i = 0; i < input.length; i++) {
+ result[i] = input[i].content;
+ }
+ return result;
+}
+
+List<String> listFilledNotGrowable(List<Input> input) {
+ List<String> result = List<String>.filled(input.length, "", growable: false);
+ for (int i = 0; i < input.length; i++) {
+ result[i] = input[i].content;
+ }
+ return result;
+}
+
+List<String> mapToList(List<Input> input) {
+ return input.map((e) => e.content).toList();
+}
+
+void main() {
+ // Dry run
+ for (Test test in tests) {
+ test.performTest(
+ registry: new Registry(),
+ runs: 5,
+ iterations: 10,
+ scenarios: scenarios);
+ }
+ // Actual test
+ Registry registry = new Registry();
+ for (Test test in tests) {
+ test.performTest(
+ registry: registry, runs: 10, iterations: 100000, scenarios: scenarios);
+ }
+ SeriesSet seriesSet = registry.generateSeriesSet();
+ print('== Raw data ==');
+ for (Scenario scenario in scenarios.keys) {
+ print(seriesSet.getFullSpreadByScenario(scenario));
+ }
+ print('== Reduced averages ==');
+ SeriesSet reducedSeriesSet = seriesSet.filter((list) => removeMax(list, 3));
+ for (Scenario scenario in scenarios.keys) {
+ print(reducedSeriesSet.getAveragedSpreadByScenario(scenario));
+ }
+}
diff --git a/pkg/front_end/benchmarks/patterns/test_sets_from_list_mapping.dart b/pkg/front_end/benchmarks/patterns/test_sets_from_list_mapping.dart
new file mode 100644
index 0000000..7bffec6
--- /dev/null
+++ b/pkg/front_end/benchmarks/patterns/test_sets_from_list_mapping.dart
@@ -0,0 +1,194 @@
+// Copyright (c) 2022, 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.
+
+import 'util.dart';
+
+typedef TestFunction<T, U> = Set<U> Function(List<T>);
+
+class InputOutputData<T, U> {
+ final List<T> input;
+ final Set<U> output;
+
+ const InputOutputData(this.input, this.output);
+}
+
+const Strategy simpleAddStrategy = Strategy('simple-add', '''
+Add entries to a list one at a time.''');
+
+const Strategy mapToSetStrategy = Strategy('mapToSet', '''
+Create the set via new Set.from([...].map([...]).''');
+
+const Strategy listGenerateGrowableStrategy =
+ Strategy('list-generate-growable', '''
+Create list via List.generate with growable = true.''');
+
+const Strategy listGenerateNotGrowableStrategy =
+ Strategy('list-generate-not-growable', '''
+Create list via List.generate with growable = false.''');
+
+const Strategy listFilledGrowableStrategy = Strategy('list-filled-growable', '''
+Create list via List.generate with growable = true.''');
+
+const Strategy listFilledNotGrowableStrategy =
+ Strategy('list-filled-not-growable', '''
+Create list via List.generate with growable = false.''');
+
+const Scenario emptyScenario = Scenario('empty', '''
+The input and output is empty.''');
+const Scenario oneEntryScenario = Scenario('one', '''
+The input is one entry.''');
+const Scenario severalEntriesScenario = Scenario('several', '''
+The input has several entries.''');
+
+class Input {
+ final String content;
+
+ const Input(this.content);
+}
+
+Map<Scenario, InputOutputData<Input, String>> scenarios = {
+ emptyScenario: const InputOutputData([], {}),
+ oneEntryScenario: const InputOutputData([Input("a")], {"a"}),
+ severalEntriesScenario: const InputOutputData(
+ [
+ Input("a"),
+ Input("b"),
+ Input("c"),
+ Input("d"),
+ Input("e"),
+ Input("f"),
+ ],
+ {
+ "a",
+ "b",
+ "c",
+ "d",
+ "e",
+ "f",
+ },
+ ),
+};
+
+class Test<T, U> {
+ final int size;
+ final Map<Strategy, TestFunction<T, U>> strategies;
+
+ const Test(this.size, this.strategies);
+
+ void _test(Registry registry, SeriesKey key, int runs, int iterations,
+ List<T> input, Set<U> expectedResult, TestFunction<T, U> testFunction) {
+ for (int run = 0; run < runs; run++) {
+ Stopwatch sw = new Stopwatch();
+ for (int i = 0; i < iterations; i++) {
+ sw.start();
+ Set<U> actualOutput = testFunction(input);
+ sw.stop();
+ checkEquals(actualOutput, expectedResult);
+ }
+ registry.registerData(key, size, sw.elapsedMicroseconds);
+ }
+ }
+
+ void checkEquals(Set<U> a, Set<U> b) {
+ if (a.length != b.length) throw "length for $a vs $b";
+ Set<U> copy = new Set<U>.of(a);
+ copy.removeAll(b);
+ if (copy.isNotEmpty) throw "Not same content";
+ }
+
+ void performTest(
+ {required Registry registry,
+ required int runs,
+ required int iterations,
+ required Map<Scenario, InputOutputData<T, U>> scenarios}) {
+ for (MapEntry<Scenario, InputOutputData<T, U>> scenario
+ in scenarios.entries) {
+ List<T> scenarioInput = scenario.value.input;
+ Set<U> scenarioExpectedOutput = scenario.value.output;
+ for (MapEntry<Strategy, TestFunction<T, U>> entry in strategies.entries) {
+ _test(registry, new SeriesKey(entry.key, scenario.key), runs,
+ iterations, scenarioInput, scenarioExpectedOutput, entry.value);
+ }
+ }
+ }
+}
+
+List<Test<Input, String>> tests = [
+ // "size" isn't used here...
+ Test<Input, String>(-1, {
+ simpleAddStrategy: simplyAdd,
+ listGenerateGrowableStrategy: listGenerateGrowable,
+ listGenerateNotGrowableStrategy: listGenerateNotGrowable,
+ listFilledGrowableStrategy: listFilledGrowable,
+ listFilledNotGrowableStrategy: listFilledNotGrowable,
+ mapToSetStrategy: mapToSet,
+ }),
+];
+
+Set<String> simplyAdd(List<Input> input) {
+ Set<String> result = {};
+ for (int i = 0; i < input.length; i++) {
+ result.add(input[i].content);
+ }
+ return result;
+}
+
+Set<String> listGenerateGrowable(List<Input> input) {
+ return Set<String>.from(List<String>.generate(
+ input.length, (index) => input[index].content,
+ growable: true));
+}
+
+Set<String> listGenerateNotGrowable(List<Input> input) {
+ return Set<String>.from(List<String>.generate(
+ input.length, (index) => input[index].content,
+ growable: false));
+}
+
+Set<String> listFilledGrowable(List<Input> input) {
+ List<String> result = List<String>.filled(input.length, "", growable: true);
+ for (int i = 0; i < input.length; i++) {
+ result[i] = input[i].content;
+ }
+ return Set<String>.from(result);
+}
+
+Set<String> listFilledNotGrowable(List<Input> input) {
+ List<String> result = List<String>.filled(input.length, "", growable: false);
+ for (int i = 0; i < input.length; i++) {
+ result[i] = input[i].content;
+ }
+ return Set<String>.from(result);
+}
+
+Set<String> mapToSet(List<Input> input) {
+ return new Set<String>.from(input.map((e) => e.content));
+}
+
+void main() {
+ // Dry run
+ for (Test test in tests) {
+ test.performTest(
+ registry: new Registry(),
+ runs: 5,
+ iterations: 10,
+ scenarios: scenarios);
+ }
+ // Actual test
+ Registry registry = new Registry();
+ for (Test test in tests) {
+ test.performTest(
+ registry: registry, runs: 10, iterations: 100000, scenarios: scenarios);
+ }
+ SeriesSet seriesSet = registry.generateSeriesSet();
+ print('== Raw data ==');
+ for (Scenario scenario in scenarios.keys) {
+ print(seriesSet.getFullSpreadByScenario(scenario));
+ }
+ print('== Reduced averages ==');
+ SeriesSet reducedSeriesSet = seriesSet.filter((list) => removeMax(list, 3));
+ for (Scenario scenario in scenarios.keys) {
+ print(reducedSeriesSet.getAveragedSpreadByScenario(scenario));
+ }
+}
diff --git a/pkg/front_end/lib/src/fasta/combinator.dart b/pkg/front_end/lib/src/fasta/combinator.dart
index 9f07af0..4ac777e 100644
--- a/pkg/front_end/lib/src/fasta/combinator.dart
+++ b/pkg/front_end/lib/src/fasta/combinator.dart
@@ -10,10 +10,10 @@
CombinatorBuilder(this.isShow, this.names, int charOffset, Uri fileUri);
CombinatorBuilder.show(Iterable<String> names, int charOffset, Uri fileUri)
- : this(true, new Set<String>.from(names), charOffset, fileUri);
+ : this(true, new Set<String>.of(names), charOffset, fileUri);
CombinatorBuilder.hide(Iterable<String> names, int charOffset, Uri fileUri)
- : this(false, new Set<String>.from(names), charOffset, fileUri);
+ : this(false, new Set<String>.of(names), charOffset, fileUri);
bool get isHide => !isShow;
}
diff --git a/pkg/front_end/lib/src/fasta/get_dependencies.dart b/pkg/front_end/lib/src/fasta/get_dependencies.dart
index 1db1afa..284b335 100644
--- a/pkg/front_end/lib/src/fasta/get_dependencies.dart
+++ b/pkg/front_end/lib/src/fasta/get_dependencies.dart
@@ -54,6 +54,6 @@
kernelTarget.setEntryPoints(<Uri>[script]);
dillTarget.buildOutlines();
await kernelTarget.loader.buildOutlines();
- return new List<Uri>.from(c.dependencies);
+ return new List<Uri>.of(c.dependencies);
});
}
diff --git a/pkg/front_end/lib/src/fasta/incremental_compiler.dart b/pkg/front_end/lib/src/fasta/incremental_compiler.dart
index 2a1e8b7..8542b60 100644
--- a/pkg/front_end/lib/src/fasta/incremental_compiler.dart
+++ b/pkg/front_end/lib/src/fasta/incremental_compiler.dart
@@ -394,7 +394,7 @@
// Compute which libraries to output and which (previous) errors/warnings
// we have to reissue. In the process do some cleanup too.
List<Library> compiledLibraries =
- new List<Library>.from(currentKernelTarget.loader.libraries);
+ new List<Library>.of(currentKernelTarget.loader.libraries);
Map<Uri, Source> uriToSource = componentWithDill!.uriToSource;
_experimentalCompilationPostCompilePatchup(
experimentalInvalidation, compiledLibraries, uriToSource);
@@ -2047,7 +2047,7 @@
IncrementalKernelTarget? lastGoodKernelTarget = this._lastGoodKernelTarget;
if (lastGoodKernelTarget != null) {
Set<Uri> uris =
- new Set<Uri>.from(lastGoodKernelTarget.loader.libraryImportUris);
+ new Set<Uri>.of(lastGoodKernelTarget.loader.libraryImportUris);
uris.removeAll(_dillLoadedData!.loader.libraryImportUris);
if (_previousSourceBuilders != null) {
for (Library library in _previousSourceBuilders!) {
@@ -2578,7 +2578,7 @@
// Save any new component-problems.
_addProblemsAsJson(componentWithDill.problemsAsJson);
- return new List<String>.from(issuedProblems);
+ return new List<String>.of(issuedProblems);
}
void saveComponentProblems(Component component) {
diff --git a/pkg/front_end/lib/src/fasta/incremental_serializer.dart b/pkg/front_end/lib/src/fasta/incremental_serializer.dart
index 5803a9a..7289a11 100644
--- a/pkg/front_end/lib/src/fasta/incremental_serializer.dart
+++ b/pkg/front_end/lib/src/fasta/incremental_serializer.dart
@@ -175,7 +175,7 @@
}
bool isSelfContained(Component component) {
- Set<Library> got = new Set<Library>.from(component.libraries);
+ Set<Library> got = new Set<Library>.of(component.libraries);
for (Library lib in component.libraries) {
for (LibraryDependency dependency in lib.dependencies) {
if (!got.contains(dependency.targetLibrary)) {
diff --git a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
index 03930e4..10a9389 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -1901,7 +1901,7 @@
}
List<Object?>? argumentsOriginalOrder;
if (libraryBuilder.enableNamedArgumentsAnywhereInLibrary) {
- argumentsOriginalOrder = new List<Object?>.from(arguments);
+ argumentsOriginalOrder = new List<Object?>.of(arguments);
}
int firstNamedArgumentIndex = arguments.length;
int positionalCount = 0;
@@ -1951,6 +1951,7 @@
assert(
positionalIndex == positional.length && namedIndex == named.length);
} else {
+ // arguments have non-null Expression entries after the initial loop.
positional = new List<Expression>.from(
arguments.getRange(0, firstNamedArgumentIndex));
named = new List<NamedExpression>.from(
@@ -1962,6 +1963,8 @@
} else {
// TODO(kmillikin): Find a way to avoid allocating a second list in the
// case where there were no named arguments, which is a common one.
+
+ // arguments have non-null Expression entries after the initial loop.
push(forest.createArguments(
beginToken.offset, new List<Expression>.from(arguments),
argumentsOriginalOrder: argumentsOriginalOrder));
@@ -4885,8 +4888,8 @@
}
List<NamedExpression> named = forest.argumentsNamed(arguments);
if (named.isNotEmpty) {
- Set<String> parameterNames =
- new Set.from(function.namedParameters.map((a) => a.name));
+ Set<String?> parameterNames =
+ new Set.of(function.namedParameters.map((a) => a.name));
for (NamedExpression argument in named) {
if (!parameterNames.contains(argument.name)) {
return fasta.templateNoSuchNamedParameter
@@ -4897,7 +4900,7 @@
}
if (function.namedParameters.isNotEmpty) {
if (libraryBuilder.isNonNullableByDefault) {
- Set<String> argumentNames = new Set.from(named.map((a) => a.name));
+ Set<String> argumentNames = new Set.of(named.map((a) => a.name));
for (VariableDeclaration parameter in function.namedParameters) {
if (parameter.isRequired && !argumentNames.contains(parameter.name)) {
return fasta.templateValueForRequiredParameterNotProvidedError
@@ -4958,7 +4961,7 @@
List<NamedExpression> named = forest.argumentsNamed(arguments);
if (named.isNotEmpty) {
Set<String> names =
- new Set.from(function.namedParameters.map((a) => a.name));
+ new Set.of(function.namedParameters.map((a) => a.name));
for (NamedExpression argument in named) {
if (!names.contains(argument.name)) {
return fasta.templateNoSuchNamedParameter
@@ -4969,7 +4972,7 @@
}
if (function.namedParameters.isNotEmpty) {
if (libraryBuilder.isNonNullableByDefault) {
- Set<String> argumentNames = new Set.from(named.map((a) => a.name));
+ Set<String> argumentNames = new Set.of(named.map((a) => a.name));
for (NamedType parameter in function.namedParameters) {
if (parameter.isRequired && !argumentNames.contains(parameter.name)) {
return fasta.templateValueForRequiredParameterNotProvidedError
@@ -6053,7 +6056,7 @@
noLocation,
noLocation,
// New list because the declarations are not a growable list.
- new List<Statement>.from(
+ new List<Statement>.of(
forest.variablesDeclarationExtractDeclarations(lvalue)));
} else {
effects = forest.createExpressionStatement(
@@ -7147,7 +7150,7 @@
Arguments? arguments, Expression expression) {
if (arguments == null) return expression;
List<Expression> expressions =
- new List<Expression>.from(forest.argumentsPositional(arguments));
+ new List<Expression>.of(forest.argumentsPositional(arguments));
for (NamedExpression named in forest.argumentsNamed(arguments)) {
expressions.add(named.value);
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index 63f0ffd..88168b6 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -286,7 +286,7 @@
Reference reference = entry.key;
Constant? value = visitConstant(entry.value);
if (value != null) {
- fieldValues ??= new Map<Reference, Constant>.from(node.fieldValues);
+ fieldValues ??= new Map<Reference, Constant>.of(node.fieldValues);
fieldValues[reference] = value;
}
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/forest.dart b/pkg/front_end/lib/src/fasta/kernel/forest.dart
index 9ce125d..73decad 100644
--- a/pkg/front_end/lib/src/fasta/kernel/forest.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/forest.dart
@@ -374,7 +374,7 @@
for (int i = 0; i < statements.length; i++) {
Statement statement = statements[i];
if (statement is _VariablesDeclaration) {
- copy ??= new List<Statement>.from(statements.getRange(0, i));
+ copy ??= new List<Statement>.of(statements.getRange(0, i));
copy.addAll(statement.declarations);
} else if (copy != null) {
copy.add(statement);
@@ -592,7 +592,7 @@
Statement wrapVariables(Statement statement) {
if (statement is _VariablesDeclaration) {
return new Block(
- new List<Statement>.from(statement.declarations, growable: true))
+ new List<Statement>.of(statement.declarations, growable: true))
..fileOffset = statement.fileOffset;
} else if (statement is VariableDeclaration) {
return new Block(<Statement>[statement])
diff --git a/pkg/front_end/lib/src/fasta/kernel/hierarchy/members_node.dart b/pkg/front_end/lib/src/fasta/kernel/hierarchy/members_node.dart
index 81fd945..f93f47e 100644
--- a/pkg/front_end/lib/src/fasta/kernel/hierarchy/members_node.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/hierarchy/members_node.dart
@@ -2352,7 +2352,7 @@
}
}
if (contextMap.isEmpty) return;
- List<String> names = new List<String>.from(contextMap.keys)..sort();
+ List<String> names = new List<String>.of(contextMap.keys)..sort();
List<LocatedMessage> context = <LocatedMessage>[];
for (int i = 0; i < names.length; i++) {
context.add(contextMap[names[i]]!);
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
index 86144de..33786c8 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
@@ -412,7 +412,7 @@
installSyntheticConstructors(sourceClassBuilders);
loader.resolveConstructors();
component =
- link(new List<Library>.from(loader.libraries), nameRoot: nameRoot);
+ link(new List<Library>.of(loader.libraries), nameRoot: nameRoot);
computeCoreTypes();
loader.buildClassHierarchy(sourceClassBuilders, objectClassBuilder);
loader.checkSupertypes(sourceClassBuilders, enumClass);
diff --git a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
index fb348d8..2e98155 100644
--- a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
@@ -2382,10 +2382,10 @@
}
List<VariableDeclaration> sortedFromDeclared =
- new List.from(declaredFunction.namedParameters)
+ new List.of(declaredFunction.namedParameters)
..sort(compareNamedParameters);
List<VariableDeclaration> sortedFromInterface =
- new List.from(interfaceFunction.namedParameters)
+ new List.of(interfaceFunction.namedParameters)
..sort(compareNamedParameters);
Iterator<VariableDeclaration> declaredNamedParameters =
sortedFromDeclared.iterator;
diff --git a/pkg/front_end/lib/src/fasta/source/source_constructor_builder.dart b/pkg/front_end/lib/src/fasta/source/source_constructor_builder.dart
index dcaf732..8f7cfc8 100644
--- a/pkg/front_end/lib/src/fasta/source/source_constructor_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_constructor_builder.dart
@@ -681,7 +681,7 @@
void ensureGrowableFormals() {
if (formals != null) {
- formals = new List<FormalParameterBuilder>.from(formals!, growable: true);
+ formals = new List<FormalParameterBuilder>.of(formals!, growable: true);
} else {
formals = <FormalParameterBuilder>[];
}
diff --git a/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart b/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart
index aaf1d48..68b6741 100644
--- a/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_enum_builder.dart
@@ -27,7 +27,9 @@
import '../fasta_codes.dart'
show
LocatedMessage,
+ messageEnumEntryWithTypeArgumentsWithoutArguments,
messageNoUnnamedConstructorInObject,
+ noLength,
templateDuplicatedDeclaration,
templateDuplicatedDeclarationCause,
templateDuplicatedDeclarationSyntheticCause,
@@ -556,6 +558,13 @@
constructorBuilder is! SourceConstructorBuilder) {
// TODO(cstefantsova): Report an error.
} else {
+ if (enumConstantInfo.argumentsBeginToken == null &&
+ enumConstantInfo.constructorReferenceBuilder?.typeArguments !=
+ null) {
+ addProblem(messageEnumEntryWithTypeArgumentsWithoutArguments,
+ enumConstantInfo.charOffset, noLength);
+ }
+
Arguments arguments;
List<Expression> enumSyntheticArguments = <Expression>[
new IntLiteral(index++),
diff --git a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
index a01a8c4..c67945d 100644
--- a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
@@ -1836,7 +1836,7 @@
classScope,
constructorScope,
this,
- new List<ConstructorReferenceBuilder>.from(constructorReferences),
+ new List<ConstructorReferenceBuilder>.of(constructorReferences),
startOffset,
nameOffset,
endOffset,
diff --git a/pkg/front_end/lib/src/fasta/source/source_loader.dart b/pkg/front_end/lib/src/fasta/source/source_loader.dart
index f481250..3e21692 100644
--- a/pkg/front_end/lib/src/fasta/source/source_loader.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_loader.dart
@@ -885,7 +885,7 @@
// setting a breakpoint on line 42 of some import uri mean, if the uri
// represented several files?
List<String> newPathSegments =
- new List<String>.from(importUri.pathSegments);
+ new List<String>.of(importUri.pathSegments);
newPathSegments.add(library.fileUri.pathSegments.last);
newPathSegments[0] = "${newPathSegments[0]}-patch";
importUri = importUri.replace(pathSegments: newPathSegments);
diff --git a/pkg/front_end/lib/src/kernel_generator_impl.dart b/pkg/front_end/lib/src/kernel_generator_impl.dart
index 2470a1a..948c756 100644
--- a/pkg/front_end/lib/src/kernel_generator_impl.dart
+++ b/pkg/front_end/lib/src/kernel_generator_impl.dart
@@ -183,7 +183,7 @@
includeHierarchyAndCoreTypes ? kernelTarget.loader.hierarchy : null,
coreTypes:
includeHierarchyAndCoreTypes ? kernelTarget.loader.coreTypes : null,
- deps: new List<Uri>.from(CompilerContext.current.dependencies),
+ deps: new List<Uri>.of(CompilerContext.current.dependencies),
kernelTargetForTesting: retainDataForTesting ? kernelTarget : null);
}, () => sourceLoader?.currentUriForCrashReporting ?? options.inputs.first);
}
diff --git a/pkg/front_end/messages.status b/pkg/front_end/messages.status
index c7e820f..74da302 100644
--- a/pkg/front_end/messages.status
+++ b/pkg/front_end/messages.status
@@ -217,6 +217,8 @@
EnumDeclaresConstFactory/example: Fail
EnumDeclaresFactory/analyzerCode: Fail
EnumDeclaresFactory/example: Fail
+EnumEntryWithTypeArgumentsWithoutArguments/analyzerCode: Fail
+EnumEntryWithTypeArgumentsWithoutArguments/example: Fail
EnumInstantiation/example: Fail
EnumSupertypeOfNonAbstractClass/analyzerCode: Fail
EnumSupertypeOfNonAbstractClass/example: Fail
diff --git a/pkg/front_end/messages.yaml b/pkg/front_end/messages.yaml
index 55b8acb6..67467be 100644
--- a/pkg/front_end/messages.yaml
+++ b/pkg/front_end/messages.yaml
@@ -5458,3 +5458,6 @@
EnumSupertypeOfNonAbstractClass:
problemMessage: "Non-abstract class '#name' has 'Enum' as a superinterface."
+
+EnumEntryWithTypeArgumentsWithoutArguments:
+ problemMessage: "Missing arguments in enum constructor invocation."
diff --git a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart
index a645a364..bf5caf0 100644
--- a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart
+++ b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart
@@ -5,7 +5,8 @@
enum E<X, Y> {
one<int, String>(),
two<double, num>(),
- three<int, int>.named(42);
+ three<int, int>.named(42),
+ four<num, bool>; // Error.
const E();
const E.named(int value);
diff --git a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.strong.expect b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.strong.expect
index 899e7e9f..7321935 100644
--- a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.strong.expect
+++ b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.strong.expect
@@ -1,12 +1,20 @@
library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart:9:3: Error: Missing arguments in enum constructor invocation.
+// four<num, bool>; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
class E<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> extends core::_Enum /*isEnum*/ {
- static const field core::List<self::E<dynamic, dynamic>> values = #C10;
+ static const field core::List<self::E<dynamic, dynamic>> values = #C13;
static const field self::E<core::int, core::String> one = #C3;
static const field self::E<core::double, core::num> two = #C6;
static const field self::E<core::int, core::int> three = #C9;
+ static const field self::E<dynamic, dynamic> four = #C12;
const constructor •(core::int index, core::String name) → self::E<self::E::X%, self::E::Y%>
: super core::_Enum::•(index, name)
;
@@ -28,13 +36,16 @@
#C7 = 2
#C8 = "three"
#C9 = self::E<core::int, core::int> {index:#C7, _name:#C8}
- #C10 = <self::E<dynamic, dynamic>>[#C3, #C6, #C9]
+ #C10 = 3
+ #C11 = "four"
+ #C12 = self::E<core::num, core::bool> {index:#C10, _name:#C11}
+ #C13 = <self::E<dynamic, dynamic>>[#C3, #C6, #C9, #C12]
}
Constructor coverage from constants:
org-dartlang-testcase:///entries_with_type_arguments.dart:
-- E. (from org-dartlang-testcase:///entries_with_type_arguments.dart:10:9)
+- E. (from org-dartlang-testcase:///entries_with_type_arguments.dart:11:9)
- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
-- E.named (from org-dartlang-testcase:///entries_with_type_arguments.dart:11:9)
+- E.named (from org-dartlang-testcase:///entries_with_type_arguments.dart:12:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.strong.transformed.expect b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.strong.transformed.expect
index 899e7e9f..7321935 100644
--- a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.strong.transformed.expect
@@ -1,12 +1,20 @@
library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart:9:3: Error: Missing arguments in enum constructor invocation.
+// four<num, bool>; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
class E<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> extends core::_Enum /*isEnum*/ {
- static const field core::List<self::E<dynamic, dynamic>> values = #C10;
+ static const field core::List<self::E<dynamic, dynamic>> values = #C13;
static const field self::E<core::int, core::String> one = #C3;
static const field self::E<core::double, core::num> two = #C6;
static const field self::E<core::int, core::int> three = #C9;
+ static const field self::E<dynamic, dynamic> four = #C12;
const constructor •(core::int index, core::String name) → self::E<self::E::X%, self::E::Y%>
: super core::_Enum::•(index, name)
;
@@ -28,13 +36,16 @@
#C7 = 2
#C8 = "three"
#C9 = self::E<core::int, core::int> {index:#C7, _name:#C8}
- #C10 = <self::E<dynamic, dynamic>>[#C3, #C6, #C9]
+ #C10 = 3
+ #C11 = "four"
+ #C12 = self::E<core::num, core::bool> {index:#C10, _name:#C11}
+ #C13 = <self::E<dynamic, dynamic>>[#C3, #C6, #C9, #C12]
}
Constructor coverage from constants:
org-dartlang-testcase:///entries_with_type_arguments.dart:
-- E. (from org-dartlang-testcase:///entries_with_type_arguments.dart:10:9)
+- E. (from org-dartlang-testcase:///entries_with_type_arguments.dart:11:9)
- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
-- E.named (from org-dartlang-testcase:///entries_with_type_arguments.dart:11:9)
+- E.named (from org-dartlang-testcase:///entries_with_type_arguments.dart:12:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.textual_outline.expect b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.textual_outline.expect
index 4fa6f4d..c2d1e7f 100644
--- a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.textual_outline.expect
@@ -1,2 +1,2 @@
-enum E<X, Y> { one<int, String>(), two<double, num>(), three<int, int>.named(42); const E(); const E.named(int value); }
+enum E<X, Y> { one<int, String>(), two<double, num>(), three<int, int>.named(42), four<num, bool>; const E(); const E.named(int value); }
main() {}
diff --git a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.expect b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.expect
index fbd0a6f..5598791 100644
--- a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.expect
+++ b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.expect
@@ -1,12 +1,20 @@
library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart:9:3: Error: Missing arguments in enum constructor invocation.
+// four<num, bool>; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
class E<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> extends core::_Enum /*isEnum*/ {
- static const field core::List<self::E<dynamic, dynamic>> values = #C10;
+ static const field core::List<self::E<dynamic, dynamic>> values = #C13;
static const field self::E<core::int, core::String> one = #C3;
static const field self::E<core::double, core::num> two = #C6;
static const field self::E<core::int, core::int> three = #C9;
+ static const field self::E<dynamic, dynamic> four = #C12;
const constructor •(core::int index, core::String name) → self::E<self::E::X%, self::E::Y%>
: super core::_Enum::•(index, name)
;
@@ -28,13 +36,16 @@
#C7 = 2
#C8 = "three"
#C9 = self::E<core::int*, core::int*> {index:#C7, _name:#C8}
- #C10 = <self::E<dynamic, dynamic>*>[#C3, #C6, #C9]
+ #C10 = 3
+ #C11 = "four"
+ #C12 = self::E<core::num*, core::bool*> {index:#C10, _name:#C11}
+ #C13 = <self::E<dynamic, dynamic>*>[#C3, #C6, #C9, #C12]
}
Constructor coverage from constants:
org-dartlang-testcase:///entries_with_type_arguments.dart:
-- E. (from org-dartlang-testcase:///entries_with_type_arguments.dart:10:9)
+- E. (from org-dartlang-testcase:///entries_with_type_arguments.dart:11:9)
- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
-- E.named (from org-dartlang-testcase:///entries_with_type_arguments.dart:11:9)
+- E.named (from org-dartlang-testcase:///entries_with_type_arguments.dart:12:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.modular.expect b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.modular.expect
index fbd0a6f..5598791 100644
--- a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.modular.expect
@@ -1,12 +1,20 @@
library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart:9:3: Error: Missing arguments in enum constructor invocation.
+// four<num, bool>; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
class E<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> extends core::_Enum /*isEnum*/ {
- static const field core::List<self::E<dynamic, dynamic>> values = #C10;
+ static const field core::List<self::E<dynamic, dynamic>> values = #C13;
static const field self::E<core::int, core::String> one = #C3;
static const field self::E<core::double, core::num> two = #C6;
static const field self::E<core::int, core::int> three = #C9;
+ static const field self::E<dynamic, dynamic> four = #C12;
const constructor •(core::int index, core::String name) → self::E<self::E::X%, self::E::Y%>
: super core::_Enum::•(index, name)
;
@@ -28,13 +36,16 @@
#C7 = 2
#C8 = "three"
#C9 = self::E<core::int*, core::int*> {index:#C7, _name:#C8}
- #C10 = <self::E<dynamic, dynamic>*>[#C3, #C6, #C9]
+ #C10 = 3
+ #C11 = "four"
+ #C12 = self::E<core::num*, core::bool*> {index:#C10, _name:#C11}
+ #C13 = <self::E<dynamic, dynamic>*>[#C3, #C6, #C9, #C12]
}
Constructor coverage from constants:
org-dartlang-testcase:///entries_with_type_arguments.dart:
-- E. (from org-dartlang-testcase:///entries_with_type_arguments.dart:10:9)
+- E. (from org-dartlang-testcase:///entries_with_type_arguments.dart:11:9)
- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
-- E.named (from org-dartlang-testcase:///entries_with_type_arguments.dart:11:9)
+- E.named (from org-dartlang-testcase:///entries_with_type_arguments.dart:12:9)
diff --git a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.outline.expect b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.outline.expect
index 718544d..c39aa4b 100644
--- a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.outline.expect
@@ -1,12 +1,20 @@
library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart:9:3: Error: Missing arguments in enum constructor invocation.
+// four<num, bool>; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
class E<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> extends core::_Enum /*isEnum*/ {
- static const field core::List<self::E<dynamic, dynamic>> values = const <self::E<dynamic, dynamic>>[self::E::one, self::E::two, self::E::three];
+ static const field core::List<self::E<dynamic, dynamic>> values = const <self::E<dynamic, dynamic>>[self::E::one, self::E::two, self::E::three, self::E::four];
static const field self::E<core::int, core::String> one = const self::E::•<core::int, core::String>(0, "one");
static const field self::E<core::double, core::num> two = const self::E::•<core::double, core::num>(1, "two");
static const field self::E<core::int, core::int> three = const self::E::named<core::int, core::int>(2, "three", 42);
+ static const field self::E<dynamic, dynamic> four = const self::E::•<core::num, core::bool>(3, "four");
const constructor •(core::int index, core::String name) → self::E<self::E::X%, self::E::Y%>
: super core::_Enum::•(index, name)
;
@@ -21,8 +29,9 @@
Extra constant evaluation status:
-Evaluated: ListLiteral @ org-dartlang-testcase:///entries_with_type_arguments.dart:5:6 -> ListConstant(const <E<dynamic, dynamic>*>[const E<int*, String*>{_Enum.index: 0, _Enum._name: "one"}, const E<double*, num*>{_Enum.index: 1, _Enum._name: "two"}, const E<int*, int*>{_Enum.index: 2, _Enum._name: "three"}])
+Evaluated: ListLiteral @ org-dartlang-testcase:///entries_with_type_arguments.dart:5:6 -> ListConstant(const <E<dynamic, dynamic>*>[const E<int*, String*>{_Enum.index: 0, _Enum._name: "one"}, const E<double*, num*>{_Enum.index: 1, _Enum._name: "two"}, const E<int*, int*>{_Enum.index: 2, _Enum._name: "three"}, const E<num*, bool*>{_Enum.index: 3, _Enum._name: "four"}])
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///entries_with_type_arguments.dart:6:3 -> InstanceConstant(const E<int*, String*>{_Enum.index: 0, _Enum._name: "one"})
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///entries_with_type_arguments.dart:7:3 -> InstanceConstant(const E<double*, num*>{_Enum.index: 1, _Enum._name: "two"})
Evaluated: ConstructorInvocation @ org-dartlang-testcase:///entries_with_type_arguments.dart:8:3 -> InstanceConstant(const E<int*, int*>{_Enum.index: 2, _Enum._name: "three"})
-Extra constant evaluation: evaluated: 11, effectively constant: 4
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///entries_with_type_arguments.dart:9:3 -> InstanceConstant(const E<num*, bool*>{_Enum.index: 3, _Enum._name: "four"})
+Extra constant evaluation: evaluated: 12, effectively constant: 5
diff --git a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.transformed.expect b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.transformed.expect
index fbd0a6f..5598791 100644
--- a/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart.weak.transformed.expect
@@ -1,12 +1,20 @@
library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/enhanced_enums/entries_with_type_arguments.dart:9:3: Error: Missing arguments in enum constructor invocation.
+// four<num, bool>; // Error.
+// ^
+//
import self as self;
import "dart:core" as core;
class E<X extends core::Object? = dynamic, Y extends core::Object? = dynamic> extends core::_Enum /*isEnum*/ {
- static const field core::List<self::E<dynamic, dynamic>> values = #C10;
+ static const field core::List<self::E<dynamic, dynamic>> values = #C13;
static const field self::E<core::int, core::String> one = #C3;
static const field self::E<core::double, core::num> two = #C6;
static const field self::E<core::int, core::int> three = #C9;
+ static const field self::E<dynamic, dynamic> four = #C12;
const constructor •(core::int index, core::String name) → self::E<self::E::X%, self::E::Y%>
: super core::_Enum::•(index, name)
;
@@ -28,13 +36,16 @@
#C7 = 2
#C8 = "three"
#C9 = self::E<core::int*, core::int*> {index:#C7, _name:#C8}
- #C10 = <self::E<dynamic, dynamic>*>[#C3, #C6, #C9]
+ #C10 = 3
+ #C11 = "four"
+ #C12 = self::E<core::num*, core::bool*> {index:#C10, _name:#C11}
+ #C13 = <self::E<dynamic, dynamic>*>[#C3, #C6, #C9, #C12]
}
Constructor coverage from constants:
org-dartlang-testcase:///entries_with_type_arguments.dart:
-- E. (from org-dartlang-testcase:///entries_with_type_arguments.dart:10:9)
+- E. (from org-dartlang-testcase:///entries_with_type_arguments.dart:11:9)
- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart:76:9)
- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart:25:9)
-- E.named (from org-dartlang-testcase:///entries_with_type_arguments.dart:11:9)
+- E.named (from org-dartlang-testcase:///entries_with_type_arguments.dart:12:9)
diff --git a/pkg/front_end/tool/generate_ast_coverage.dart b/pkg/front_end/tool/generate_ast_coverage.dart
index 833e707..7471ac0 100644
--- a/pkg/front_end/tool/generate_ast_coverage.dart
+++ b/pkg/front_end/tool/generate_ast_coverage.dart
@@ -114,7 +114,7 @@
/// Returns the set of [${innerName}Kind]s that were not visited by [visitor].
Set<${innerName}Kind> missing${innerName}s($visitorName visitor) {
Set<${innerName}Kind> all =
- new Set<${innerName}Kind>.from(${innerName}Kind.values);
+ new Set<${innerName}Kind>.of(${innerName}Kind.values);
all.removeAll(visitor.visited);
return all;
}''');
diff --git a/pkg/kernel/lib/ast.dart b/pkg/kernel/lib/ast.dart
index 51270c4..a2fce2f 100644
--- a/pkg/kernel/lib/ast.dart
+++ b/pkg/kernel/lib/ast.dart
@@ -3740,7 +3740,7 @@
named.sort();
// We need create a copy of the list of type parameters, otherwise
// transformations like erasure don't work.
- List<TypeParameter> typeParametersCopy = new List<TypeParameter>.from(
+ List<TypeParameter> typeParametersCopy = new List<TypeParameter>.of(
parent is Constructor
? parent.enclosingClass.typeParameters
: typeParameters);
@@ -3790,9 +3790,9 @@
// We need create a copy of the list of type parameters, otherwise
// transformations like erasure don't work.
List<TypeParameter> classTypeParametersCopy =
- List.from(parentConstructor.enclosingClass.typeParameters);
+ List.of(parentConstructor.enclosingClass.typeParameters);
List<TypeParameter> typedefTypeParametersCopy =
- List.from(typedef.typeParameters);
+ List.of(typedef.typeParameters);
List<DartType> asTypeArguments =
getAsTypeArguments(typedefTypeParametersCopy, library);
TypedefType typedefType =
@@ -3834,9 +3834,9 @@
"Only run this method on a factory");
// We need create a copy of the list of type parameters, otherwise
// transformations like erasure don't work.
- List<TypeParameter> classTypeParametersCopy = List.from(typeParameters);
+ List<TypeParameter> classTypeParametersCopy = List.of(typeParameters);
List<TypeParameter> typedefTypeParametersCopy =
- List.from(typedef.typeParameters);
+ List.of(typedef.typeParameters);
List<DartType> asTypeArguments =
getAsTypeArguments(typedefTypeParametersCopy, library);
TypedefType typedefType =
diff --git a/pkg/kernel/lib/binary/ast_from_binary.dart b/pkg/kernel/lib/binary/ast_from_binary.dart
index b1f1dcd..e067807 100644
--- a/pkg/kernel/lib/binary/ast_from_binary.dart
+++ b/pkg/kernel/lib/binary/ast_from_binary.dart
@@ -598,7 +598,7 @@
_byteOffset = start - 4;
}
_byteOffset = savedByteOffset;
- return new List.from(index.reversed);
+ return new List.of(index.reversed);
}
void _checkEmptyInput() {
diff --git a/pkg/kernel/lib/class_hierarchy.dart b/pkg/kernel/lib/class_hierarchy.dart
index e231e8f..cf9320c 100644
--- a/pkg/kernel/lib/class_hierarchy.dart
+++ b/pkg/kernel/lib/class_hierarchy.dart
@@ -929,7 +929,7 @@
if (_recordedAmbiguousSupertypes.isNotEmpty &&
reissueAmbiguousSupertypesFor != null) {
Set<Library> libs =
- new Set<Library>.from(reissueAmbiguousSupertypesFor.libraries);
+ new Set<Library>.of(reissueAmbiguousSupertypesFor.libraries);
for (Class class_ in _recordedAmbiguousSupertypes.keys) {
if (!libs.contains(class_.enclosingLibrary)) continue;
List<Supertype> recorded = _recordedAmbiguousSupertypes[class_]!;
@@ -1714,7 +1714,7 @@
}
ClassSet union(ClassSet other) {
- Set<Class> result = new Set<Class>.from(_classes);
+ Set<Class> result = new Set<Class>.of(_classes);
result.addAll(other._classes);
return new ClassSet(result);
}
diff --git a/pkg/kernel/lib/clone.dart b/pkg/kernel/lib/clone.dart
index a407a13..43d7c32 100644
--- a/pkg/kernel/lib/clone.dart
+++ b/pkg/kernel/lib/clone.dart
@@ -468,7 +468,7 @@
for (SwitchCase switchCase in node.cases) {
switchCases[switchCase] = new SwitchCase(
switchCase.expressions.map(clone).toList(),
- new List<int>.from(switchCase.expressionOffsets),
+ new List<int>.of(switchCase.expressionOffsets),
dummyStatement,
isDefault: switchCase.isDefault);
}
diff --git a/pkg/kernel/lib/src/coverage.dart b/pkg/kernel/lib/src/coverage.dart
index 01b9483..35a5692 100644
--- a/pkg/kernel/lib/src/coverage.dart
+++ b/pkg/kernel/lib/src/coverage.dart
@@ -1145,7 +1145,7 @@
/// Returns the set of [MemberKind]s that were not visited by [visitor].
Set<MemberKind> missingMembers(CoverageVisitor visitor) {
- Set<MemberKind> all = new Set<MemberKind>.from(MemberKind.values);
+ Set<MemberKind> all = new Set<MemberKind>.of(MemberKind.values);
all.removeAll(visitor.visited);
return all;
}
@@ -1153,35 +1153,35 @@
/// Returns the set of [InitializerKind]s that were not visited by [visitor].
Set<InitializerKind> missingInitializers(CoverageVisitor visitor) {
Set<InitializerKind> all =
- new Set<InitializerKind>.from(InitializerKind.values);
+ new Set<InitializerKind>.of(InitializerKind.values);
all.removeAll(visitor.visited);
return all;
}
/// Returns the set of [ExpressionKind]s that were not visited by [visitor].
Set<ExpressionKind> missingExpressions(CoverageVisitor visitor) {
- Set<ExpressionKind> all = new Set<ExpressionKind>.from(ExpressionKind.values);
+ Set<ExpressionKind> all = new Set<ExpressionKind>.of(ExpressionKind.values);
all.removeAll(visitor.visited);
return all;
}
/// Returns the set of [StatementKind]s that were not visited by [visitor].
Set<StatementKind> missingStatements(CoverageVisitor visitor) {
- Set<StatementKind> all = new Set<StatementKind>.from(StatementKind.values);
+ Set<StatementKind> all = new Set<StatementKind>.of(StatementKind.values);
all.removeAll(visitor.visited);
return all;
}
/// Returns the set of [DartTypeKind]s that were not visited by [visitor].
Set<DartTypeKind> missingDartTypes(CoverageVisitor visitor) {
- Set<DartTypeKind> all = new Set<DartTypeKind>.from(DartTypeKind.values);
+ Set<DartTypeKind> all = new Set<DartTypeKind>.of(DartTypeKind.values);
all.removeAll(visitor.visited);
return all;
}
/// Returns the set of [ConstantKind]s that were not visited by [visitor].
Set<ConstantKind> missingConstants(CoverageVisitor visitor) {
- Set<ConstantKind> all = new Set<ConstantKind>.from(ConstantKind.values);
+ Set<ConstantKind> all = new Set<ConstantKind>.of(ConstantKind.values);
all.removeAll(visitor.visited);
return all;
}
diff --git a/pkg/kernel/lib/src/standard_bounds.dart b/pkg/kernel/lib/src/standard_bounds.dart
index 61590da..9dc32175 100644
--- a/pkg/kernel/lib/src/standard_bounds.dart
+++ b/pkg/kernel/lib/src/standard_bounds.dart
@@ -849,7 +849,7 @@
int n = klass.typeParameters.length;
List<DartType> leftArguments = type1.typeArguments;
List<DartType> rightArguments = type2.typeArguments;
- List<DartType> typeArguments = new List<DartType>.from(leftArguments);
+ List<DartType> typeArguments = new List<DartType>.of(leftArguments);
for (int i = 0; i < n; ++i) {
int variance = klass.typeParameters[i].variance;
if (variance == Variance.contravariant) {
diff --git a/pkg/kernel/lib/target/targets.dart b/pkg/kernel/lib/target/targets.dart
index 173d367..ea7721a 100644
--- a/pkg/kernel/lib/target/targets.dart
+++ b/pkg/kernel/lib/target/targets.dart
@@ -1070,7 +1070,7 @@
super.performOutlineTransformations(component);
if (!excludeNonSources) return;
- List<Library> libraries = new List.from(component.libraries);
+ List<Library> libraries = new List.of(component.libraries);
component.libraries.clear();
Set<Uri> include = sources.toSet();
for (Library library in libraries) {
diff --git a/pkg/kernel/lib/util/graph.dart b/pkg/kernel/lib/util/graph.dart
index eef4b6b..7708269 100644
--- a/pkg/kernel/lib/util/graph.dart
+++ b/pkg/kernel/lib/util/graph.dart
@@ -227,7 +227,7 @@
}
// Collect and remove all dependencies.
- Set<T> left = new Set<T>.from(graph.vertices);
+ Set<T> left = new Set<T>.of(graph.vertices);
Set<T> transitive = {};
while (workList.isNotEmpty) {
T removed = workList.removeLast();
diff --git a/tools/VERSION b/tools/VERSION
index 237ad2c..97705ad 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 17
PATCH 0
-PRERELEASE 52
+PRERELEASE 53
PRERELEASE_PATCH 0
\ No newline at end of file
