Version 1.23.0-dev.4.0
Merge 005453346eeb178d888cd858e1a5d5584c143642 into dev
diff --git a/pkg/analysis_server/lib/src/analysis_server.dart b/pkg/analysis_server/lib/src/analysis_server.dart
index 1ed2a48..7f6e898 100644
--- a/pkg/analysis_server/lib/src/analysis_server.dart
+++ b/pkg/analysis_server/lib/src/analysis_server.dart
@@ -1864,14 +1864,18 @@
NotificationManager notificationManager =
analysisServer.notificationManager;
String path = result.path;
- if (notificationManager != null) {
- notificationManager.recordAnalysisErrors(
- NotificationManager.serverId,
- path,
- server.doAnalysisError_listFromEngine(
- result.driver.analysisOptions, result.lineInfo, result.errors));
- } else {
- new_sendErrorNotification(analysisServer, result);
+ if (analysisServer.shouldSendErrorsNotificationFor(path)) {
+ if (notificationManager != null) {
+ notificationManager.recordAnalysisErrors(
+ NotificationManager.serverId,
+ path,
+ server.doAnalysisError_listFromEngine(
+ result.driver.analysisOptions,
+ result.lineInfo,
+ result.errors));
+ } else {
+ new_sendErrorNotification(analysisServer, result);
+ }
}
CompilationUnit unit = result.unit;
if (unit != null) {
diff --git a/pkg/analyzer/lib/src/dart/ast/ast.dart b/pkg/analyzer/lib/src/dart/ast/ast.dart
index 0a364cf..398fa65 100644
--- a/pkg/analyzer/lib/src/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/src/dart/ast/ast.dart
@@ -5831,8 +5831,9 @@
..add(_typeParameters)
..add(equals)
..add(_functionType);
+
@override
- Element get element => null;
+ Element get element => name.staticElement;
@override
GenericFunctionType get functionType => _functionType;
@@ -5855,7 +5856,6 @@
return visitor.visitGenericTypeAlias(this);
}
- // TODO: implement element
@override
void visitChildren(AstVisitor visitor) {
super.visitChildren(visitor);
@@ -9239,6 +9239,9 @@
*/
TypeAnnotation _type;
+ @override
+ ParameterElement element;
+
/**
* Initialize a newly created formal parameter. Either or both of the
* [comment] and [metadata] can be `null` if the parameter does not have the
@@ -9276,7 +9279,7 @@
super._childEntities..add(keyword)..add(_type)..add(identifier);
@override
- Token get endToken => identifier.endToken;
+ Token get endToken => identifier?.endToken ?? type?.endToken;
@override
bool get isConst => keyword?.keyword == Keyword.CONST;
diff --git a/pkg/analyzer/lib/src/dart/ast/utilities.dart b/pkg/analyzer/lib/src/dart/ast/utilities.dart
index 920e585..8090044 100644
--- a/pkg/analyzer/lib/src/dart/ast/utilities.dart
+++ b/pkg/analyzer/lib/src/dart/ast/utilities.dart
@@ -6428,12 +6428,16 @@
@override
bool visitSimpleFormalParameter(SimpleFormalParameter node) {
SimpleFormalParameter toNode = this._toNode as SimpleFormalParameter;
- return _and(
+ if (_and(
_isEqualNodes(node.documentationComment, toNode.documentationComment),
_isEqualNodeLists(node.metadata, toNode.metadata),
_isEqualTokens(node.keyword, toNode.keyword),
_isEqualNodes(node.type, toNode.type),
- _isEqualNodes(node.identifier, toNode.identifier));
+ _isEqualNodes(node.identifier, toNode.identifier))) {
+ (toNode as SimpleFormalParameterImpl).element = node.element;
+ return true;
+ }
+ return false;
}
@override
diff --git a/pkg/analyzer/lib/src/dart/element/builder.dart b/pkg/analyzer/lib/src/dart/element/builder.dart
index 3524404..cea4664 100644
--- a/pkg/analyzer/lib/src/dart/element/builder.dart
+++ b/pkg/analyzer/lib/src/dart/element/builder.dart
@@ -13,6 +13,7 @@
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/error/error.dart';
import 'package:analyzer/exception/exception.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/type.dart';
import 'package:analyzer/src/error/codes.dart';
@@ -1405,6 +1406,9 @@
parameter.hasImplicitType = true;
}
_currentHolder.addParameter(parameter);
+ if (normalParameter is SimpleFormalParameterImpl) {
+ normalParameter.element = parameter;
+ }
parameterName.staticElement = parameter;
normalParameter.accept(this);
return null;
@@ -1441,10 +1445,10 @@
@override
Object visitSimpleFormalParameter(SimpleFormalParameter node) {
+ ParameterElementImpl parameter;
if (node.parent is! DefaultFormalParameter) {
SimpleIdentifier parameterName = node.identifier;
- ParameterElementImpl parameter =
- new ParameterElementImpl.forNode(parameterName);
+ parameter = new ParameterElementImpl.forNode(parameterName);
_setCodeRange(parameter, node);
parameter.isConst = node.isConst;
parameter.isExplicitlyCovariant = node.covariantKeyword != null;
@@ -1455,11 +1459,12 @@
parameter.hasImplicitType = true;
}
_currentHolder.addParameter(parameter);
- parameterName.staticElement = parameter;
+ (node as SimpleFormalParameterImpl).element = parameter;
+ parameterName?.staticElement = parameter;
}
super.visitSimpleFormalParameter(node);
- (node.element as ElementImpl).metadata =
- _createElementAnnotations(node.metadata);
+ parameter ??= node.element;
+ parameter?.metadata = _createElementAnnotations(node.metadata);
return null;
}
diff --git a/pkg/analyzer/lib/src/generated/declaration_resolver.dart b/pkg/analyzer/lib/src/generated/declaration_resolver.dart
index f87f5f6..333fdef 100644
--- a/pkg/analyzer/lib/src/generated/declaration_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/declaration_resolver.dart
@@ -9,6 +9,7 @@
import 'package:analyzer/dart/ast/visitor.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/exception/exception.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
import 'package:analyzer/src/dart/element/builder.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/type.dart';
@@ -122,8 +123,12 @@
@override
Object visitDefaultFormalParameter(DefaultFormalParameter node) {
+ NormalFormalParameter normalParameter = node.parameter;
ParameterElement element =
- _match(node.parameter.identifier, _walker.getParameter());
+ _match(normalParameter.identifier, _walker.getParameter());
+ if (normalParameter is SimpleFormalParameterImpl) {
+ normalParameter.element = node.identifier.staticElement;
+ }
Expression defaultValue = node.defaultValue;
if (defaultValue != null) {
_walk(
@@ -133,7 +138,7 @@
});
}
_walk(new ElementWalker.forParameter(element), () {
- node.parameter.accept(this);
+ normalParameter.accept(this);
});
_resolveMetadata(node, node.metadata, element);
return null;
@@ -365,6 +370,8 @@
if (node.parent is! DefaultFormalParameter) {
ParameterElement element =
_match(node.identifier, _walker.getParameter());
+ (node as SimpleFormalParameterImpl).element =
+ node.identifier.staticElement;
_walk(new ElementWalker.forParameter(element), () {
super.visitSimpleFormalParameter(node);
});
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 291f075..95c01cb 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -10076,7 +10076,7 @@
} else {
declaredType = _typeNameResolver._getType(typeName);
}
- Element element = node.identifier.staticElement;
+ Element element = node.element;
if (element is ParameterElementImpl) {
element.declaredType = declaredType;
} else {
diff --git a/pkg/analyzer/test/generated/resolver_test.dart b/pkg/analyzer/test/generated/resolver_test.dart
index 8d21db67..5ce754c 100644
--- a/pkg/analyzer/test/generated/resolver_test.dart
+++ b/pkg/analyzer/test/generated/resolver_test.dart
@@ -15,6 +15,7 @@
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/file_system/memory_file_system.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
import 'package:analyzer/src/dart/element/builder.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/type.dart';
@@ -3202,9 +3203,9 @@
InterfaceType intType = _typeProvider.intType;
TypeName intTypeName = AstTestFactory.typeName4("int");
String innerParameterName = "a";
- SimpleFormalParameter parameter =
+ SimpleFormalParameterImpl parameter =
AstTestFactory.simpleFormalParameter3(innerParameterName);
- parameter.identifier.staticElement =
+ parameter.element = parameter.identifier.staticElement =
ElementFactory.requiredParameter(innerParameterName);
String outerParameterName = "p";
FormalParameter node = AstTestFactory.fieldFormalParameter(
@@ -3415,8 +3416,8 @@
test_visitSimpleFormalParameter_noType() async {
// p
- FormalParameter node = AstTestFactory.simpleFormalParameter3("p");
- node.identifier.staticElement =
+ SimpleFormalParameterImpl node = AstTestFactory.simpleFormalParameter3("p");
+ node.element = node.identifier.staticElement =
new ParameterElementImpl.forNode(AstTestFactory.identifier3("p"));
expect(_resolveFormalParameter(node), same(_typeProvider.dynamicType));
_listener.assertNoErrors();
@@ -3426,11 +3427,11 @@
// int p
InterfaceType intType = _typeProvider.intType;
ClassElement intElement = intType.element;
- FormalParameter node = AstTestFactory.simpleFormalParameter4(
+ SimpleFormalParameterImpl node = AstTestFactory.simpleFormalParameter4(
AstTestFactory.typeName(intElement), "p");
SimpleIdentifier identifier = node.identifier;
ParameterElementImpl element = new ParameterElementImpl.forNode(identifier);
- identifier.staticElement = element;
+ node.element = identifier.staticElement = element;
expect(_resolveFormalParameter(node, [intElement]), same(intType));
_listener.assertNoErrors();
}
diff --git a/pkg/analyzer/test/src/summary/element_text.dart b/pkg/analyzer/test/src/summary/element_text.dart
new file mode 100644
index 0000000..f995195
--- /dev/null
+++ b/pkg/analyzer/test/src/summary/element_text.dart
@@ -0,0 +1,749 @@
+// Copyright (c) 2017, 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 'dart:io';
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:test/test.dart';
+
+/**
+ * Set this path to automatically replace expectations in invocations of
+ * [checkElementText] with the new actual texts.
+ */
+const String _testPath = null;
+
+/**
+ * The list of replacements that update expectations.
+ */
+final List<_Replacement> _replacements = [];
+
+/**
+ * The cached content of the file with the [_testPath].
+ */
+String _testCode;
+
+/**
+ * The cache line information for the [_testPath] file.
+ */
+LineInfo _testCodeLines;
+
+void applyCheckElementTextReplacements() {
+ if (_testPath != null && _replacements.isNotEmpty) {
+ _replacements.sort((a, b) => b.offset - a.offset);
+ String newCode = _testCode;
+ _replacements.forEach((r) {
+ newCode =
+ newCode.substring(0, r.offset) + r.text + newCode.substring(r.end);
+ });
+ new File(_testPath).writeAsStringSync(newCode);
+ }
+}
+
+/**
+ * Write the given [library] elements into the canonical text presentation
+ * taking into account the specified 'withX' options. Then compare the
+ * actual text with the given [expected] one.
+ */
+void checkElementText(LibraryElement library, String expected,
+ {bool withOffsets: false}) {
+ var writer = new _ElementWriter(withOffsets: withOffsets);
+ writer.writeLibraryElement(library);
+ String actualText = writer.buffer.toString();
+ if (_testPath != null && actualText != expected) {
+ if (_testCode == null) {
+ _testCode = new File(_testPath).readAsStringSync();
+ _testCodeLines = new LineInfo.fromContent(_testCode);
+ }
+
+ try {
+ throw 42;
+ } catch (e, trace) {
+ String traceString = trace.toString();
+
+ // Assuming traceString contains "$_testPath:$invocationLine:$column",
+ // figure out the value of invocationLine.
+
+ int testFilePathOffset = traceString.indexOf(_testPath);
+ expect(testFilePathOffset, isNonNegative);
+
+ // Sanity check: there must be ':' after the path.
+ expect(traceString[testFilePathOffset + _testPath.length], ':');
+
+ int lineOffset = testFilePathOffset + _testPath.length + ':'.length;
+ int invocationLine = int.parse(traceString.substring(
+ lineOffset, traceString.indexOf(':', lineOffset)));
+ int invocationOffset = _testCodeLines.getOffsetOfLine(invocationLine - 1);
+
+ const String rawStringPrefix = "r'''";
+ int expectationOffset =
+ _testCode.indexOf(rawStringPrefix, invocationOffset);
+
+ // Sanity check: there must be no other strings or blocks.
+ expect(_testCode.substring(invocationOffset, expectationOffset),
+ isNot(anyOf(contains("'"), contains('"'), contains('}'))));
+
+ expectationOffset += rawStringPrefix.length;
+ int expectationEnd = _testCode.indexOf("'''", expectationOffset);
+
+ _replacements.add(new _Replacement(
+ expectationOffset, expectationEnd, '\n' + actualText));
+ }
+ }
+
+ // Print the actual text to simplify copy/paste into the expectation.
+ if (actualText != expected) {
+ print('-------- Actual --------');
+ print(actualText + '------------------------');
+ }
+
+ expect(actualText, expected);
+}
+
+/**
+ * Writes the canonical text presentation of elements.
+ */
+class _ElementWriter {
+ final bool withOffsets;
+ final StringBuffer buffer = new StringBuffer();
+
+ _ElementWriter({this.withOffsets: false});
+
+ bool isDynamicType(DartType type) => type is DynamicTypeImpl;
+
+ bool isEnumElement(Element e) {
+ return e is ClassElement && e.isEnum;
+ }
+
+ void newLineIfNotEmpty() {
+ if (buffer.isNotEmpty) {
+ buffer.writeln();
+ }
+ }
+
+ void writeBodyModifiers(ExecutableElement e) {
+ if (e.isAsynchronous) {
+ expect(e.isSynchronous, isFalse);
+ buffer.write(' async');
+ }
+
+ if (e.isSynchronous && e.isGenerator) {
+ expect(e.isAsynchronous, isFalse);
+ buffer.write(' sync');
+ }
+
+ writeIf(e.isGenerator, '*');
+ }
+
+ void writeClassElement(ClassElement e) {
+ writeDocumentation(e);
+ writeMetadata(e, '', '\n');
+
+ writeIf(e.isAbstract, 'abstract ');
+
+ if (e.isEnum) {
+ buffer.write('enum ');
+ } else {
+ buffer.write('class ');
+ }
+
+ writeIf(e.isMixinApplication, 'alias ');
+
+ writeName(e);
+ writeTypeParameterElements(e.typeParameters);
+
+ if (e.supertype != null && e.supertype.displayName != 'Object' ||
+ e.mixins.isNotEmpty) {
+ buffer.write(' extends ');
+ writeType(e.supertype);
+ }
+
+ writeList(' with ', '', e.mixins, ', ', writeType);
+ writeList(' implements ', '', e.interfaces, ', ', writeType);
+
+ buffer.writeln(' {');
+
+ e.fields.forEach(writeFieldElement);
+ e.accessors.forEach(writePropertyAccessorElement);
+
+ if (e.isEnum) {
+ expect(e.constructors, isEmpty);
+ } else {
+ expect(e.constructors, isNotEmpty);
+ }
+
+ if (e.constructors.length == 1 &&
+ e.constructors[0].isSynthetic &&
+ e.mixins.isEmpty) {
+ expect(e.constructors[0].parameters, isEmpty);
+ } else {
+ e.constructors.forEach(writeConstructorElement);
+ }
+
+ e.methods.forEach(writeMethodElement);
+ buffer.writeln('}');
+ }
+
+ void writeConstructorElement(ConstructorElement e) {
+ writeDocumentation(e, ' ');
+ writeMetadata(e, ' ', '\n');
+
+ buffer.write(' ');
+
+ writeIf(e.isSynthetic, 'synthetic ');
+ writeIf(e.isExternal, 'external ');
+ writeIf(e.isConst, 'const ');
+ writeIf(e.isFactory, 'factory ');
+
+ buffer.write(e.enclosingElement.name);
+ if (e.name.isNotEmpty) {
+ buffer.write('.');
+ writeName(e);
+ }
+
+ writeParameterElements(e.parameters);
+
+ {
+ ConstructorElement redirected = e.redirectedConstructor;
+ if (redirected != null) {
+ buffer.write(' = ');
+ buffer.write(redirected.returnType);
+ if (redirected.name.isNotEmpty) {
+ buffer.write('.');
+ buffer.write(redirected.name);
+ }
+ }
+ }
+
+ if (e is ConstructorElementImpl) {
+ if (e.constantInitializers != null) {
+ writeList(' : ', '', e.constantInitializers, ', ', writeExpression);
+ }
+ }
+
+ expect(e.isAsynchronous, isFalse);
+ expect(e.isGenerator, isFalse);
+
+ buffer.writeln(';');
+ }
+
+ void writeDocumentation(Element e, [String prefix = '']) {
+ if (e.documentationComment != null) {
+ buffer.write(prefix);
+ buffer.writeln(e.documentationComment);
+ }
+ }
+
+ void writeExportElement(ExportElement e) {
+ writeMetadata(e, '', '\n');
+ buffer.write('export ');
+ writeUri(e, e.exportedLibrary.source);
+
+ e.combinators.forEach(writeNamespaceCombinator);
+
+ buffer.writeln(';');
+ }
+
+ void writeExpression(AstNode e) {
+ if (e is Annotation) {
+ buffer.write('@');
+ writeExpression(e.name);
+ if (e.constructorName != null) {
+ buffer.write('.');
+ writeExpression(e.constructorName);
+ }
+ if (e.arguments != null) {
+ writeList('(', ')', e.arguments.arguments, ', ', writeExpression,
+ includeEmpty: true);
+ }
+ } else if (e is AssertInitializer) {
+ buffer.write('assert(');
+ writeExpression(e.condition);
+ if (e.message != null) {
+ buffer.write(', ');
+ writeExpression(e.message);
+ }
+ buffer.write(')');
+ } else if (e is BinaryExpression) {
+ writeExpression(e.leftOperand);
+ buffer.write(' ');
+ buffer.write(e.operator.lexeme);
+ buffer.write(' ');
+ writeExpression(e.rightOperand);
+ } else if (e is BooleanLiteral) {
+ buffer.write(e.value);
+ } else if (e is ConditionalExpression) {
+ writeExpression(e.condition);
+ buffer.write(' ? ');
+ writeExpression(e.thenExpression);
+ buffer.write(' : ');
+ writeExpression(e.elseExpression);
+ } else if (e is ConstructorFieldInitializer) {
+ writeExpression(e.fieldName);
+ buffer.write(' = ');
+ writeExpression(e.expression);
+ } else if (e is ConstructorName) {
+ writeExpression(e.type);
+ if (e.name != null) {
+ buffer.write('.');
+ writeExpression(e.name);
+ }
+ } else if (e is DoubleLiteral) {
+ buffer.write(e.value);
+ } else if (e is InstanceCreationExpression) {
+ buffer.write(e.keyword.lexeme);
+ buffer.write(' ');
+ writeExpression(e.constructorName);
+ writeList('(', ')', e.argumentList.arguments, ', ', writeExpression,
+ includeEmpty: true);
+ } else if (e is IntegerLiteral) {
+ buffer.write(e.value);
+ } else if (e is InterpolationExpression) {
+ buffer.write(r'${');
+ writeExpression(e.expression);
+ buffer.write(r'}');
+ } else if (e is InterpolationString) {
+ buffer.write(e.value.replaceAll("'", r"\'"));
+ } else if (e is ListLiteral) {
+ if (e.constKeyword != null) {
+ buffer.write('const ');
+ }
+ if (e.typeArguments != null) {
+ writeList('<', '>', e.typeArguments.arguments, ', ', writeExpression);
+ }
+ writeList('[', ']', e.elements, ', ', writeExpression,
+ includeEmpty: true);
+ } else if (e is Label) {
+ writeExpression(e.label);
+ buffer.write(': ');
+ } else if (e is MapLiteral) {
+ if (e.constKeyword != null) {
+ buffer.write('const ');
+ }
+ if (e.typeArguments != null) {
+ writeList('<', '>', e.typeArguments.arguments, ', ', writeExpression);
+ }
+ writeList('{', '}', e.entries, ', ', writeExpression, includeEmpty: true);
+ } else if (e is MapLiteralEntry) {
+ writeExpression(e.key);
+ buffer.write(': ');
+ writeExpression(e.value);
+ } else if (e is NamedExpression) {
+ writeExpression(e.name);
+ buffer.write(e.expression);
+ } else if (e is NullLiteral) {
+ buffer.write('null');
+ } else if (e is PrefixExpression) {
+ buffer.write(e.operator.lexeme);
+ writeExpression(e.operand);
+ } else if (e is PrefixedIdentifier) {
+ writeExpression(e.prefix);
+ buffer.write('.');
+ writeExpression(e.identifier);
+ } else if (e is PropertyAccess) {
+ writeExpression(e.target);
+ buffer.write('.');
+ writeExpression(e.propertyName);
+ } else if (e is RedirectingConstructorInvocation) {
+ buffer.write('this');
+ if (e.constructorName != null) {
+ buffer.write('.');
+ writeExpression(e.constructorName);
+ }
+ writeList('(', ')', e.argumentList.arguments, ', ', writeExpression,
+ includeEmpty: true);
+ } else if (e is SimpleIdentifier) {
+ buffer.write(e.name);
+ } else if (e is SimpleStringLiteral) {
+ buffer.write("'");
+ buffer.write(e.value.replaceAll("'", r"\'"));
+ buffer.write("'");
+ } else if (e is StringInterpolation) {
+ buffer.write("'");
+ e.elements.forEach(writeExpression);
+ buffer.write("'");
+ } else if (e is SuperConstructorInvocation) {
+ buffer.write('super');
+ if (e.constructorName != null) {
+ buffer.write('.');
+ writeExpression(e.constructorName);
+ }
+ writeList('(', ')', e.argumentList.arguments, ', ', writeExpression,
+ includeEmpty: true);
+ } else if (e is SuperExpression) {
+ buffer.write('super');
+ } else if (e is SymbolLiteral) {
+ buffer.write('#');
+ writeList('', '', e.components, '.',
+ (Token token) => buffer.write(token.lexeme));
+ } else if (e is ThisExpression) {
+ buffer.write('this');
+ } else if (e is TypeName) {
+ writeExpression(e.name);
+ if (e.typeArguments != null) {
+ writeList('<', '>', e.typeArguments.arguments, ', ', writeExpression);
+ }
+ } else {
+ fail('Unsupported expression type: ${e.runtimeType}');
+ }
+ }
+
+ void writeFieldElement(FieldElement e) {
+ if (e.isSynthetic && !isEnumElement(e.enclosingElement)) {
+ return;
+ }
+
+ writeDocumentation(e, ' ');
+ writeMetadata(e, ' ', '\n');
+
+ buffer.write(' ');
+
+ writeIf(e.isStatic, 'static ');
+ writeIf(e is FieldElementImpl && e.isCovariant, 'covariant ');
+
+ writePropertyInducingElement(e);
+ }
+
+ void writeFunctionElement(FunctionElement e) {
+ writeIf(e.isExternal, 'external ');
+
+ writeType2(e.returnType);
+
+ writeName(e);
+
+ writeTypeParameterElements(e.typeParameters);
+ writeParameterElements(e.parameters);
+
+ writeBodyModifiers(e);
+
+ buffer.writeln(' {}');
+ }
+
+ void writeFunctionTypeAliasElement(FunctionTypeAliasElement e) {
+ writeDocumentation(e);
+ writeMetadata(e, '', '\n');
+
+ buffer.write('typedef ');
+ writeType2(e.returnType);
+
+ writeName(e);
+
+ writeTypeParameterElements(e.typeParameters);
+ writeParameterElements(e.parameters);
+
+ buffer.writeln(';');
+ }
+
+ void writeIf(bool flag, String str) {
+ if (flag) {
+ buffer.write(str);
+ }
+ }
+
+ void writeImportElement(ImportElement e) {
+ if (!e.isSynthetic) {
+ writeMetadata(e, '', '\n');
+ buffer.write('import ');
+ writeUri(e, e.importedLibrary.source);
+
+ writeIf(e.isDeferred, ' deferred');
+
+ if (e.prefix != null) {
+ buffer.write(' as ');
+ writeName(e.prefix);
+ if (withOffsets) {
+ buffer.write('(${e.prefixOffset})');
+ }
+ }
+
+ e.combinators.forEach(writeNamespaceCombinator);
+
+ buffer.writeln(';');
+ }
+ }
+
+ void writeLibraryElement(LibraryElement e) {
+ if (e.displayName != '') {
+ writeMetadata(e, '', '\n');
+ buffer.write('library ');
+ writeName(e);
+ buffer.writeln(';');
+ }
+
+ e.imports.forEach(writeImportElement);
+ e.exports.forEach(writeExportElement);
+ e.parts.forEach(writePartElement);
+
+ e.units.forEach(writeUnitElement);
+ }
+
+ void writeList<T>(String open, String close, List<T> items, String separator,
+ writeItem(T item),
+ {bool includeEmpty: false}) {
+ if (!includeEmpty && items.isEmpty) {
+ return;
+ }
+ buffer.write(open);
+ bool first = true;
+ for (T item in items) {
+ if (!first) {
+ buffer.write(separator);
+ }
+ writeItem(item);
+ first = false;
+ }
+ buffer.write(close);
+ }
+
+ void writeMetadata(Element e, String prefix, String separator) {
+ if (e.metadata.isNotEmpty) {
+ writeList(prefix, '', e.metadata, '$separator$prefix', (a) {
+ writeExpression((a as ElementAnnotationImpl).annotationAst);
+ });
+ buffer.write(separator);
+ }
+ }
+
+ void writeMethodElement(MethodElement e) {
+ writeDocumentation(e, ' ');
+ writeMetadata(e, ' ', '\n');
+
+ buffer.write(' ');
+
+ writeIf(e.isExternal, 'external ');
+ writeIf(e.isStatic, 'static ');
+
+ writeType2(e.returnType);
+
+ writeName(e);
+
+ writeTypeParameterElements(e.typeParameters);
+ writeParameterElements(e.parameters);
+
+ writeBodyModifiers(e);
+
+ if (e.isAbstract) {
+ buffer.writeln(';');
+ } else {
+ buffer.writeln(' {}');
+ }
+ }
+
+ void writeName(Element e) {
+ buffer.write(e.displayName);
+ if (withOffsets) {
+ buffer.write('@');
+ buffer.write(e.nameOffset);
+ }
+ }
+
+ void writeNamespaceCombinator(NamespaceCombinator e) {
+ if (e is ShowElementCombinator) {
+ buffer.write(' show ');
+ buffer.write(e.shownNames.join(', '));
+ } else if (e is HideElementCombinator) {
+ buffer.write(' hide ');
+ buffer.write(e.hiddenNames.join(', '));
+ }
+ }
+
+ void writeParameterElement(ParameterElement e) {
+ String defaultValueSeparator;
+ Expression defaultValue =
+ e is DefaultParameterElementImpl ? e.constantInitializer : null;
+ String closeString;
+ ParameterKind kind = e.parameterKind;
+ if (kind == ParameterKind.REQUIRED) {
+ closeString = '';
+ } else if (kind == ParameterKind.POSITIONAL) {
+ buffer.write('[');
+ defaultValueSeparator = ' = ';
+ closeString = ']';
+ } else if (kind == ParameterKind.NAMED) {
+ buffer.write('{');
+ defaultValueSeparator = ': ';
+ closeString = '}';
+ } else {
+ fail('Unknown parameter kind: $kind');
+ }
+
+ writeMetadata(e, '', ' ');
+
+ writeIf(e.isCovariant, 'covariant ');
+ writeIf(e.isFinal, 'final ');
+
+ writeType2(e.type);
+
+ if (e is FieldFormalParameterElement) {
+ buffer.write('this.');
+ }
+
+ writeName(e);
+
+ if (defaultValue != null) {
+ buffer.write(defaultValueSeparator);
+ writeExpression(defaultValue);
+ }
+
+ buffer.write(closeString);
+ }
+
+ void writeParameterElements(List<ParameterElement> elements) {
+ writeList('(', ')', elements, ', ', writeParameterElement,
+ includeEmpty: true);
+ }
+
+ void writePartElement(CompilationUnitElement e) {
+ writeMetadata(e, '', '\n');
+ buffer.write('part ');
+ writeUri(e, e.source);
+ buffer.writeln(';');
+ }
+
+ void writePropertyAccessorElement(PropertyAccessorElement e) {
+ if (e.isSynthetic) {
+ return;
+ }
+
+ if (e.enclosingElement is ClassElement) {
+ writeDocumentation(e, ' ');
+ writeMetadata(e, ' ', '\n');
+
+ buffer.write(' ');
+
+ writeIf(e.isStatic, 'static ');
+ } else {
+ writeDocumentation(e);
+ writeMetadata(e, '', '\n');
+ }
+
+ writeIf(e.isExternal, 'external ');
+
+ writeType2(e.returnType);
+
+ if (e.isGetter) {
+ buffer.write('get ');
+ } else {
+ buffer.write('set ');
+ }
+
+ writeName(e);
+
+ if (e.isSetter || e.parameters.isNotEmpty) {
+ writeParameterElements(e.parameters);
+ }
+
+ expect(e.typeParameters, isEmpty);
+
+ expect(e.isSynchronous, isTrue);
+ expect(e.isAsynchronous, isFalse);
+ expect(e.isGenerator, isFalse);
+
+ if (e.isAbstract) {
+ buffer.writeln(';');
+ } else {
+ buffer.writeln(' {}');
+ }
+ }
+
+ void writePropertyInducingElement(PropertyInducingElement e) {
+ DartType type = e.type;
+ expect(type, isNotNull);
+
+ writeIf(e.isFinal, 'final ');
+ writeIf(e.isConst, 'const ');
+ writeType2(type);
+
+ writeName(e);
+
+ if (e is ConstVariableElement) {
+ Expression initializer = (e as ConstVariableElement).constantInitializer;
+ if (initializer != null) {
+ buffer.write(' = ');
+ writeExpression(initializer);
+ }
+ }
+
+ // TODO(scheglov) Paul: One of the things that was hardest to get right
+ // when resynthesizing the element model was the synthetic function for the
+ // initializer. Can we write that out (along with its return type)?
+
+ buffer.writeln(';');
+ }
+
+ void writeTopLevelVariableElement(TopLevelVariableElement e) {
+ if (e.isSynthetic) {
+ return;
+ }
+ writeDocumentation(e);
+ writeMetadata(e, '', '\n');
+ writePropertyInducingElement(e);
+ }
+
+ void writeType(DartType type) {
+ if (type is InterfaceType) {
+ buffer.write(type.element.name);
+ if (type.element.typeParameters.isNotEmpty) {
+ writeList('<', '>', type.typeArguments, ', ', writeType);
+ }
+ } else {
+ buffer.write(type.displayName);
+ }
+ }
+
+ void writeType2(DartType type) {
+ writeType(type);
+ buffer.write(' ');
+ }
+
+ void writeTypeParameterElement(TypeParameterElement e) {
+ writeName(e);
+ if (e.bound != null) {
+ buffer.write(' extends ');
+ writeType(e.bound);
+ }
+ }
+
+ void writeTypeParameterElements(List<TypeParameterElement> elements) {
+ writeList('<', '>', elements, ', ', writeTypeParameterElement);
+ }
+
+ void writeUnitElement(CompilationUnitElement e) {
+ if (e.library.definingCompilationUnit != e) {
+ buffer.writeln('-' * 20);
+ buffer.writeln('unit: ${e.source.shortName}');
+ buffer.writeln();
+ }
+ e.functionTypeAliases.forEach(writeFunctionTypeAliasElement);
+ e.enums.forEach(writeClassElement);
+ e.types.forEach(writeClassElement);
+ e.topLevelVariables.forEach(writeTopLevelVariableElement);
+ e.accessors.forEach(writePropertyAccessorElement);
+ e.functions.forEach(writeFunctionElement);
+ }
+
+ void writeUri(UriReferencedElement e, Source source) {
+ String uri = e.uri ?? source.uri.toString();
+ buffer.write('\'$uri\'');
+ if (withOffsets) {
+ buffer.write('(');
+ buffer.write('${e.uriOffset}, ');
+ buffer.write('${e.uriEnd})');
+ buffer.write(')');
+ }
+ }
+}
+
+class _Replacement {
+ final int offset;
+ final int end;
+ final String text;
+ _Replacement(this.offset, this.end, this.text);
+}
diff --git a/pkg/analyzer/test/src/summary/resynthesize_ast_test.dart b/pkg/analyzer/test/src/summary/resynthesize_ast_test.dart
index 5efc290..139a553 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_ast_test.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_ast_test.dart
@@ -29,6 +29,7 @@
import '../context/abstract_context.dart';
import '../task/strong/inferred_type_test.dart';
+import 'element_text.dart';
import 'resynthesize_common.dart';
import 'summary_common.dart';
@@ -37,13 +38,24 @@
defineReflectiveTests(ResynthesizeAstSpecTest);
defineReflectiveTests(ResynthesizeAstStrongTest);
defineReflectiveTests(AstInferredTypeTest);
+ defineReflectiveTests(ApplyCheckElementTextReplacements);
});
}
@reflectiveTest
+class ApplyCheckElementTextReplacements {
+ test_applyReplacements() {
+ applyCheckElementTextReplacements();
+ }
+}
+
+@reflectiveTest
class AstInferredTypeTest extends AbstractResynthesizeTest
with _AstResynthesizeTestMixin, InferredTypeMixin {
@override
+ bool get isStrongMode => true;
+
+ @override
bool get mayCheckTypesOfLocals => false;
@override
@@ -686,13 +698,15 @@
@reflectiveTest
class ResynthesizeAstSpecTest extends _ResynthesizeAstTest {
@override
- AnalysisOptionsImpl createOptions() =>
- super.createOptions()..strongMode = false;
+ bool get isStrongMode => false;
}
@reflectiveTest
class ResynthesizeAstStrongTest extends _ResynthesizeAstTest {
@override
+ bool get isStrongMode => true;
+
+ @override
AnalysisOptionsImpl createOptions() =>
super.createOptions()..strongMode = true;
@@ -880,6 +894,8 @@
abstract class _ResynthesizeAstTest extends ResynthesizeTest
with _AstResynthesizeTestMixin {
+ bool get isStrongMode;
+
@override
LibraryElementImpl checkLibrary(String text,
{bool allowErrors: false, bool dumpSummaries: false}) {
@@ -907,6 +923,10 @@
DartSdk createDartSdk() => AbstractContextTest.SHARED_MOCK_SDK;
@override
+ AnalysisOptionsImpl createOptions() =>
+ super.createOptions()..strongMode = isStrongMode;
+
+ @override
TestSummaryResynthesizer encodeDecodeLibrarySource(Source source) {
return _encodeLibrary(source);
}
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index 51b77ed..c1d72d5 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -29,9 +29,12 @@
import '../../generated/test_support.dart';
import '../abstract_single_unit.dart';
import '../context/abstract_context.dart';
+import 'element_text.dart';
/**
* Abstract base class for resynthesizing and comparing elements.
+ *
+ * The return type separator: →
*/
abstract class AbstractResynthesizeTest extends AbstractSingleUnitTest {
Set<Source> otherLibrarySources = new Set<Source>();
@@ -53,6 +56,11 @@
*/
bool allowMissingFiles = false;
+ /**
+ * Return `true` if resynthesizing should be done is strong mode.
+ */
+ bool get isStrongMode;
+
void addLibrary(String uri) {
otherLibrarySources.add(context.sourceFactory.forUri(uri));
}
@@ -1317,23 +1325,105 @@
SummaryResynthesizer encodeDecodeLibrarySource(Source librarySource);
fail_library_hasExtUri() {
- checkLibrary('import "dart-ext:doesNotExist.dart";');
+ var library = checkLibrary('import "dart-ext:doesNotExist.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_class_abstract() {
- checkLibrary('abstract class C {}');
+ var library = checkLibrary('abstract class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+}
+''');
+ }
}
test_class_alias() {
- checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
+ var library =
+ checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class alias C extends D with E, F {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+class F {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class alias C extends D with E, F {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+class F {
+}
+''');
+ }
}
test_class_alias_abstract() {
- checkLibrary('abstract class C = D with E; class D {} class E {}');
+ var library =
+ checkLibrary('abstract class C = D with E; class D {} class E {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class alias C extends D with E {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class alias C extends D with E {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+''');
+ }
}
test_class_alias_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
@@ -1342,6 +1432,37 @@
class D {}
class E {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+class alias C extends D with E {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+class alias C extends D with E {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+''');
+ }
}
test_class_alias_with_forwarding_constructors() {
@@ -1359,35 +1480,122 @@
factory Base.fact2() = Base.noArgs;
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import "a.dart";
class M {}
class MixinApp = Base with M;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class M {
+}
+class alias MixinApp extends Base with M {
+ synthetic MixinApp._priv() = Base._priv;
+ synthetic MixinApp() = Base;
+ synthetic MixinApp.noArgs() = Base.noArgs;
+ synthetic MixinApp.requiredArg(dynamic x) = Base.requiredArg;
+ synthetic MixinApp.fact() = Base.fact;
+ synthetic MixinApp.fact2() = Base.fact2;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class M {
+}
+class alias MixinApp extends Base with M {
+ synthetic MixinApp._priv() = Base._priv;
+ synthetic MixinApp() = Base;
+ synthetic MixinApp.noArgs() = Base.noArgs;
+ synthetic MixinApp.requiredArg(dynamic x) = Base.requiredArg;
+ synthetic MixinApp.fact() = Base.fact;
+ synthetic MixinApp.fact2() = Base.fact2;
+}
+''');
+ }
}
test_class_alias_with_forwarding_constructors_type_substitution() {
- checkLibrary('''
+ var library = checkLibrary('''
class Base<T> {
Base.ctor(T t, List<T> l);
}
class M {}
class MixinApp = Base with M;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class Base<T> {
+ Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class alias MixinApp extends Base<dynamic> with M {
+ synthetic MixinApp.ctor(dynamic t, List<dynamic> l) = Base<T>.ctor;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class Base<T> {
+ Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class alias MixinApp extends Base<dynamic> with M {
+ synthetic MixinApp.ctor(dynamic t, List<dynamic> l) = Base<T>.ctor;
+}
+''');
+ }
}
test_class_alias_with_forwarding_constructors_type_substitution_complex() {
- checkLibrary('''
+ var library = checkLibrary('''
class Base<T> {
Base.ctor(T t, List<T> l);
}
class M {}
class MixinApp<U> = Base<List<U>> with M;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class Base<T> {
+ Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class alias MixinApp<U> extends Base<List<U>> with M {
+ synthetic MixinApp.ctor(List<U> t, List<List<U>> l) = Base<T>.ctor;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class Base<T> {
+ Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class alias MixinApp<U> extends Base<List<U>> with M {
+ synthetic MixinApp.ctor(List<U> t, List<List<U>> l) = Base<T>.ctor;
+}
+''');
+ }
}
test_class_alias_with_mixin_members() {
- checkLibrary('''
+ var library = checkLibrary('''
class C = D with E;
class D {}
class E {
@@ -1396,133 +1604,680 @@
void f() {}
int x;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class alias C extends D with E {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+ int x;
+ int get a {}
+ void set b(int i) {}
+ void f() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class alias C extends D with E {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+ int x;
+ int get a {}
+ void set b(int i) {}
+ void f() {}
+}
+''');
+ }
}
test_class_constructor_const() {
- checkLibrary('class C { const C(); }');
+ var library = checkLibrary('class C { const C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C();
+}
+''');
+ }
}
test_class_constructor_const_external() {
- checkLibrary('class C { external const C(); }');
+ var library = checkLibrary('class C { external const C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external const C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external const C();
+}
+''');
+ }
}
test_class_constructor_explicit_named() {
- checkLibrary('class C { C.foo(); }');
+ var library = checkLibrary('class C { C.foo(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.foo();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.foo();
+}
+''');
+ }
}
test_class_constructor_explicit_type_params() {
- checkLibrary('class C<T, U> { C(); }');
+ var library = checkLibrary('class C<T, U> { C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ C();
+}
+''');
+ }
}
test_class_constructor_explicit_unnamed() {
- checkLibrary('class C { C(); }');
+ var library = checkLibrary('class C { C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_class_constructor_external() {
- checkLibrary('class C { external C(); }');
+ var library = checkLibrary('class C { external C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external C();
+}
+''');
+ }
}
test_class_constructor_factory() {
- checkLibrary('class C { factory C() => null; }');
+ var library = checkLibrary('class C { factory C() => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ factory C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ factory C();
+}
+''');
+ }
}
test_class_constructor_field_formal_dynamic_dynamic() {
- checkLibrary('class C { dynamic x; C(dynamic this.x); }');
+ var library = checkLibrary('class C { dynamic x; C(dynamic this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(dynamic this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(dynamic this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_dynamic_typed() {
- checkLibrary('class C { dynamic x; C(int this.x); }');
+ var library = checkLibrary('class C { dynamic x; C(int this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(int this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(int this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_dynamic_untyped() {
- checkLibrary('class C { dynamic x; C(this.x); }');
+ var library = checkLibrary('class C { dynamic x; C(this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(dynamic this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(dynamic this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_multiple_matching_fields() {
// This is a compile-time error but it should still analyze consistently.
- checkLibrary('class C { C(this.x); int x; String x; }', allowErrors: true);
+ var library = checkLibrary('class C { C(this.x); int x; String x; }',
+ allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ String x;
+ C(int this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ String x;
+ C(int this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_no_matching_field() {
// This is a compile-time error but it should still analyze consistently.
- checkLibrary('class C { C(this.x); }', allowErrors: true);
+ var library = checkLibrary('class C { C(this.x); }', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(dynamic this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(dynamic this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_typed_dynamic() {
- checkLibrary('class C { num x; C(dynamic this.x); }', allowErrors: true);
+ var library = checkLibrary('class C { num x; C(dynamic this.x); }',
+ allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(dynamic this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(dynamic this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_typed_typed() {
- checkLibrary('class C { num x; C(int this.x); }');
+ var library = checkLibrary('class C { num x; C(int this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(int this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(int this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_typed_untyped() {
- checkLibrary('class C { num x; C(this.x); }');
+ var library = checkLibrary('class C { num x; C(this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(num this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(num this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_untyped_dynamic() {
- checkLibrary('class C { var x; C(dynamic this.x); }');
+ var library = checkLibrary('class C { var x; C(dynamic this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(dynamic this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(dynamic this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_untyped_typed() {
- checkLibrary('class C { var x; C(int this.x); }');
+ var library = checkLibrary('class C { var x; C(int this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(int this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(int this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_untyped_untyped() {
- checkLibrary('class C { var x; C(this.x); }');
+ var library = checkLibrary('class C { var x; C(this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(dynamic this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(dynamic this.x);
+}
+''');
+ }
}
test_class_constructor_fieldFormal_named_noDefault() {
- checkLibrary('class C { int x; C({this.x}); }');
+ var library = checkLibrary('class C { int x; C({this.x}); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C({int this.x});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C({int this.x});
+}
+''');
+ }
}
test_class_constructor_fieldFormal_named_withDefault() {
- checkLibrary('class C { int x; C({this.x: 42}); }');
+ var library = checkLibrary('class C { int x; C({this.x: 42}); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C({int this.x});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C({int this.x});
+}
+''');
+ }
}
test_class_constructor_fieldFormal_optional_noDefault() {
- checkLibrary('class C { int x; C([this.x]); }');
+ var library = checkLibrary('class C { int x; C([this.x]); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C([int this.x]);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C([int this.x]);
+}
+''');
+ }
}
test_class_constructor_fieldFormal_optional_withDefault() {
- checkLibrary('class C { int x; C([this.x = 42]); }');
+ var library = checkLibrary('class C { int x; C([this.x = 42]); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C([int this.x]);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C([int this.x]);
+}
+''');
+ }
}
test_class_constructor_implicit() {
- checkLibrary('class C {}');
+ var library = checkLibrary('class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_class_constructor_implicit_type_params() {
- checkLibrary('class C<T, U> {}');
+ var library = checkLibrary('class C<T, U> {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+''');
+ }
}
test_class_constructor_params() {
- checkLibrary('class C { C(x, y); }');
+ var library = checkLibrary('class C { C(x, int y); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(dynamic x, int y);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(dynamic x, int y);
+}
+''');
+ }
}
test_class_constructors() {
- checkLibrary('class C { C.foo(); C.bar(); }');
+ var library = checkLibrary('class C { C.foo(); C.bar(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.foo();
+ C.bar();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.foo();
+ C.bar();
+}
+''');
+ }
}
test_class_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
class C {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+class C {
+}
+''');
+ }
}
test_class_documented_tripleSlash() {
- checkLibrary('''
+ var library = checkLibrary('''
/// aaa
/// bbbb
/// cc
class C {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+/// aaa
+/// bbbb
+/// cc
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+/// aaa
+/// bbbb
+/// cc
+class C {
+}
+''');
+ }
}
test_class_documented_with_references() {
- checkLibrary('''
+ var library = checkLibrary('''
/**
* Docs referring to [D] and [E]
*/
@@ -1530,174 +2285,897 @@
class D {}
class E {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs referring to [D] and [E]
+ */
+class C {
+}
+class D {
+}
+class E {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs referring to [D] and [E]
+ */
+class C {
+}
+class D {
+}
+class E {
+}
+''');
+ }
}
test_class_documented_with_windows_line_endings() {
- checkLibrary('/**\r\n * Docs\r\n */\r\nclass C {}');
+ var library = checkLibrary('/**\r\n * Docs\r\n */\r\nclass C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+class C {
+}
+''');
+ }
}
test_class_field_const() {
- checkLibrary('class C { static const int i = 0; }');
+ var library = checkLibrary('class C { static const int i = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int i = 0;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int i = 0;
+}
+''');
+ }
}
test_class_field_implicit_type() {
- checkLibrary('class C { var x; }');
+ var library = checkLibrary('class C { var x; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+}
+''');
+ }
}
test_class_field_static() {
- checkLibrary('class C { static int i; }');
+ var library = checkLibrary('class C { static int i; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int i;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int i;
+}
+''');
+ }
}
test_class_fields() {
- checkLibrary('class C { int i; int j; }');
+ var library = checkLibrary('class C { int i; int j; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int i;
+ int j;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int i;
+ int j;
+}
+''');
+ }
}
test_class_getter_abstract() {
- checkLibrary('abstract class C { int get x; }');
+ var library = checkLibrary('abstract class C { int get x; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ int get x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ int get x;
+}
+''');
+ }
}
test_class_getter_external() {
- checkLibrary('class C { external int get x; }');
+ var library = checkLibrary('class C { external int get x; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external int get x {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external int get x {}
+}
+''');
+ }
}
test_class_getter_implicit_return_type() {
- checkLibrary('class C { get x => null; }');
+ var library = checkLibrary('class C { get x => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic get x {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic get x {}
+}
+''');
+ }
}
test_class_getter_static() {
- checkLibrary('class C { static int get x => null; }');
+ var library = checkLibrary('class C { static int get x => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int get x {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int get x {}
+}
+''');
+ }
}
test_class_getters() {
- checkLibrary('class C { int get x => null; get y => null; }');
+ var library = checkLibrary('class C { int get x => null; get y => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int get x {}
+ dynamic get y {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int get x {}
+ dynamic get y {}
+}
+''');
+ }
}
test_class_implicitField_getterFirst() {
- checkLibrary('class C { int get x => 0; void set x(int value) {} }');
+ var library =
+ checkLibrary('class C { int get x => 0; void set x(int value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int get x {}
+ void set x(int value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int get x {}
+ void set x(int value) {}
+}
+''');
+ }
}
test_class_implicitField_setterFirst() {
- checkLibrary('class C { void set x(int value) {} int get x => 0; }');
+ var library =
+ checkLibrary('class C { void set x(int value) {} int get x => 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(int value) {}
+ int get x {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(int value) {}
+ int get x {}
+}
+''');
+ }
}
test_class_interfaces() {
- checkLibrary('class C implements D, E {} class D {} class E {}');
+ var library =
+ checkLibrary('class C implements D, E {} class D {} class E {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C implements D, E {
+}
+class D {
+}
+class E {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C implements D, E {
+}
+class D {
+}
+class E {
+}
+''');
+ }
}
test_class_interfaces_unresolved() {
- checkLibrary('class C implements X, Y, Z {} class X {} class Z {}',
+ var library = checkLibrary(
+ 'class C implements X, Y, Z {} class X {} class Z {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C implements X, Z {
+}
+class X {
+}
+class Z {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C implements X, Z {
+}
+class X {
+}
+class Z {
+}
+''');
+ }
}
test_class_method_abstract() {
- checkLibrary('abstract class C { f(); }');
+ var library = checkLibrary('abstract class C { f(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ dynamic f();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ dynamic f();
+}
+''');
+ }
}
test_class_method_external() {
- checkLibrary('class C { external f(); }');
+ var library = checkLibrary('class C { external f(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external dynamic f() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external dynamic f() {}
+}
+''');
+ }
}
test_class_method_params() {
- checkLibrary('class C { f(x, y) {} }');
+ var library = checkLibrary('class C { f(x, y) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic f(dynamic x, dynamic y) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic f(dynamic x, dynamic y) {}
+}
+''');
+ }
}
test_class_method_static() {
- checkLibrary('class C { static f() {} }');
+ var library = checkLibrary('class C { static f() {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static dynamic f() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static dynamic f() {}
+}
+''');
+ }
}
test_class_methods() {
- checkLibrary('class C { f() {} g() {} }');
+ var library = checkLibrary('class C { f() {} g() {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic f() {}
+ dynamic g() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic f() {}
+ dynamic g() {}
+}
+''');
+ }
}
test_class_mixins() {
- checkLibrary('class C extends Object with D, E {} class D {} class E {}');
+ var library = checkLibrary(
+ 'class C extends Object with D, E {} class D {} class E {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends Object with D, E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends Object with D, E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+''');
+ }
}
test_class_mixins_unresolved() {
- checkLibrary('class C extends Object with X, Y, Z; class X {} class Z {}',
+ var library = checkLibrary(
+ 'class C extends Object with X, Y, Z; class X {} class Z {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends Object with X, Z {
+ synthetic C();
+}
+class X {
+}
+class Z {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends Object with X, Z {
+ synthetic C();
+}
+class X {
+}
+class Z {
+}
+''');
+ }
}
test_class_setter_abstract() {
- checkLibrary('abstract class C { void set x(int value); }');
+ var library = checkLibrary('abstract class C { void set x(int value); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ void set x(int value);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ void set x(int value);
+}
+''');
+ }
}
test_class_setter_external() {
- checkLibrary('class C { external void set x(int value); }');
+ var library = checkLibrary('class C { external void set x(int value); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external void set x(int value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external void set x(int value) {}
+}
+''');
+ }
}
test_class_setter_implicit_param_type() {
- checkLibrary('class C { void set x(value) {} }');
+ var library = checkLibrary('class C { void set x(value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(dynamic value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(dynamic value) {}
+}
+''');
+ }
}
test_class_setter_implicit_return_type() {
- checkLibrary('class C { set x(int value) {} }');
+ var library = checkLibrary('class C { set x(int value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(int value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic set x(int value) {}
+}
+''');
+ }
}
test_class_setter_invalid_no_parameter() {
- checkLibrary('class C { void set x() {} }');
+ var library = checkLibrary('class C { void set x() {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x() {}
+}
+''');
+ }
}
test_class_setter_static() {
- checkLibrary('class C { static void set x(int value) {} }');
+ var library = checkLibrary('class C { static void set x(int value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static void set x(int value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static void set x(int value) {}
+}
+''');
+ }
}
test_class_setters() {
- checkLibrary('class C { void set x(int value) {} set y(value) {} }');
+ var library =
+ checkLibrary('class C { void set x(int value) {} set y(value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(int value) {}
+ void set y(dynamic value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(int value) {}
+ dynamic set y(dynamic value) {}
+}
+''');
+ }
}
test_class_supertype() {
- checkLibrary('class C extends D {} class D {}');
+ var library = checkLibrary('class C extends D {} class D {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+}
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+}
+class D {
+}
+''');
+ }
}
test_class_supertype_unresolved() {
- checkLibrary('class C extends D {}', allowErrors: true);
+ var library = checkLibrary('class C extends D {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_class_type_parameters() {
- checkLibrary('class C<T, U> {}');
+ var library = checkLibrary('class C<T, U> {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+''');
+ }
}
test_class_type_parameters_bound() {
- checkLibrary('class C<T extends Object, U extends D> {} class D {}');
+ var library =
+ checkLibrary('class C<T extends Object, U extends D> {} class D {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends Object, U extends D> {
+}
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends Object, U extends D> {
+}
+class D {
+}
+''');
+ }
}
test_class_type_parameters_f_bound_complex() {
- checkLibrary('class C<T extends List<U>, U> {}');
+ var library = checkLibrary('class C<T extends List<U>, U> {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends List<U>, U> {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends List<U>, U> {
+}
+''');
+ }
}
test_class_type_parameters_f_bound_simple() {
- checkLibrary('class C<T extends U, U> {}');
+ var library = checkLibrary('class C<T extends U, U> {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends U, U> {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends U, U> {
+}
+''');
+ }
}
test_classes() {
- checkLibrary('class C {} class D {}');
+ var library = checkLibrary('class C {} class D {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+class D {
+}
+''');
+ }
}
test_closure_executable_with_return_type_from_closure() {
- checkLibrary('''
+ var library = checkLibrary('''
f() {
print(() {});
print(() => () => 0);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+''');
+ }
}
test_closure_generic() {
- checkLibrary('final f = <U, V>(U x, V y) => y;');
+ var library = checkLibrary('final f = <U, V>(U x, V y) => y;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+final <U,V>(U, V) → V f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final dynamic f;
+''');
+ }
}
test_closure_in_variable_declaration_in_part() {
addSource('/a.dart', 'part of lib; final f = (int i) => i.toDouble();');
- checkLibrary('''
+ var library = checkLibrary('''
library lib;
part "a.dart";
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+final (int) → double f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+final dynamic f;
+''');
+ }
}
test_const_invalid_field_const() {
variablesWithNotConstInitializers.add('f');
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {
static const f = 1 + foo();
@@ -1705,11 +3183,30 @@
int foo() => 42;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int f = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const dynamic f = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+ }
}
test_const_invalid_field_final() {
variablesWithNotConstInitializers.add('f');
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {
final f = 1 + foo();
@@ -1717,25 +3214,78 @@
int foo() => 42;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final int f = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic f = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+ }
}
test_const_invalid_topLevel() {
variablesWithNotConstInitializers.add('v');
- checkLibrary(
+ var library = checkLibrary(
r'''
const v = 1 + foo();
int foo() => 42;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int v = $$invalidConstExpr$$;
+int foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic v = $$invalidConstExpr$$;
+int foo() {}
+''');
+ }
}
test_const_invokeConstructor_generic_named() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C<K, V> {
const C.named(K k, V v);
}
const V = const C<int, String>.named(1, '222');
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ const C.named(K k, V v);
+}
+const C<int, String> V = const C<int, String>.named(1, '222');
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ const C.named(K k, V v);
+}
+const dynamic V = const C<int, String>.named(1, '222');
+''');
+ }
}
test_const_invokeConstructor_generic_named_imported() {
@@ -1746,10 +3296,25 @@
const C.named(K k, V v);
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = const C<int, String>.named(1, '222');
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const C<int, String> V = const C<int, String>.named(1, '222');
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic V = const C<int, String>.named(1, '222');
+''');
+ }
}
test_const_invokeConstructor_generic_named_imported_withPrefix() {
@@ -1760,28 +3325,81 @@
const C.named(K k, V v);
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = const p.C<int, String>.named(1, '222');
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const C<int, String> V = const C<int, String>.named(1, '222');
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = const C<int, String>.named(1, '222');
+''');
+ }
}
test_const_invokeConstructor_generic_noTypeArguments() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C<K, V> {
const C();
}
const V = const C();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ const C();
+}
+const C<dynamic, dynamic> V = const C();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ const C();
+}
+const dynamic V = const C();
+''');
+ }
}
test_const_invokeConstructor_generic_unnamed() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C<K, V> {
const C();
}
const V = const C<int, String>();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ const C();
+}
+const C<int, String> V = const C<int, String>();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ const C();
+}
+const dynamic V = const C<int, String>();
+''');
+ }
}
test_const_invokeConstructor_generic_unnamed_imported() {
@@ -1792,10 +3410,25 @@
const C();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = const C<int, String>();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const C<int, String> V = const C<int, String>();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic V = const C<int, String>();
+''');
+ }
}
test_const_invokeConstructor_generic_unnamed_imported_withPrefix() {
@@ -1806,19 +3439,53 @@
const C();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = const p.C<int, String>();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const C<int, String> V = const C<int, String>();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = const C<int, String>();
+''');
+ }
}
test_const_invokeConstructor_named() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
const C.named(bool a, int b, int c, {String d, double e});
}
const V = const C.named(true, 1, 2, d: 'ccc', e: 3.4);
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C.named(bool a, int b, int c, {String d}, {double e});
+}
+const C V = const C.named(true, 1, 2, d: 'ccc', e: 3.4);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C.named(bool a, int b, int c, {String d}, {double e});
+}
+const dynamic V = const C.named(true, 1, 2, d: 'ccc', e: 3.4);
+''');
+ }
}
test_const_invokeConstructor_named_imported() {
@@ -1829,10 +3496,25 @@
const C.named();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = const C.named();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const C V = const C.named();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic V = const C.named();
+''');
+ }
}
test_const_invokeConstructor_named_imported_withPrefix() {
@@ -1843,27 +3525,72 @@
const C.named();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = const p.C.named();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const C V = const C.named();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = const C.named();
+''');
+ }
}
test_const_invokeConstructor_named_unresolved() {
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {}
const V = const C.named();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+const C V = const C.named();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+const dynamic V = const C.named();
+''');
+ }
}
test_const_invokeConstructor_named_unresolved2() {
- checkLibrary(
+ var library = checkLibrary(
r'''
const V = const C.named();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = const C.named();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = const C.named();
+''');
+ }
}
test_const_invokeConstructor_named_unresolved3() {
@@ -1873,39 +3600,101 @@
class C {
}
''');
- checkLibrary(
+ var library = checkLibrary(
r'''
import 'a.dart' as p;
const V = const p.C.named();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const C V = const p.C.named();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = const p.C.named();
+''');
+ }
}
test_const_invokeConstructor_named_unresolved4() {
addLibrarySource('/a.dart', '');
- checkLibrary(
+ var library = checkLibrary(
r'''
import 'a.dart' as p;
const V = const p.C.named();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = const p.C.named();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = const p.C.named();
+''');
+ }
}
test_const_invokeConstructor_named_unresolved5() {
- checkLibrary(
+ var library = checkLibrary(
r'''
const V = const p.C.named();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = const p.C.named();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = const p.C.named();
+''');
+ }
}
test_const_invokeConstructor_unnamed() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
const C();
}
const V = const C();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C();
+}
+const C V = const C();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C();
+}
+const dynamic V = const C();
+''');
+ }
}
test_const_invokeConstructor_unnamed_imported() {
@@ -1916,10 +3705,25 @@
const C();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = const C();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const C V = const C();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic V = const C();
+''');
+ }
}
test_const_invokeConstructor_unnamed_imported_withPrefix() {
@@ -1930,45 +3734,120 @@
const C();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = const p.C();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const C V = const C();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = const C();
+''');
+ }
}
test_const_invokeConstructor_unnamed_unresolved() {
- checkLibrary(
+ var library = checkLibrary(
r'''
const V = const C();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = const C();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = const C();
+''');
+ }
}
test_const_invokeConstructor_unnamed_unresolved2() {
addLibrarySource('/a.dart', '');
- checkLibrary(
+ var library = checkLibrary(
r'''
import 'a.dart' as p;
const V = const p.C();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = const p.C();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = const p.C();
+''');
+ }
}
test_const_invokeConstructor_unnamed_unresolved3() {
- checkLibrary(
+ var library = checkLibrary(
r'''
const V = const p.C();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = const p.C();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = const p.C();
+''');
+ }
}
test_const_length_ofClassConstField() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
static const String F = '';
}
const int v = C.F.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const String F = '';
+}
+const int v = C.F.length;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const String F = '';
+}
+const int v = C.F.length;
+''');
+ }
}
test_const_length_ofClassConstField_imported() {
@@ -1979,10 +3858,25 @@
static const String F = '';
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const int v = C.F.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const int v = C.F.length;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const int v = C.F.length;
+''');
+ }
}
test_const_length_ofClassConstField_imported_withPrefix() {
@@ -1993,23 +3887,66 @@
static const String F = '';
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const int v = p.C.F.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const int v = p.C.F.length;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const int v = p.C.F.length;
+''');
+ }
}
test_const_length_ofStringLiteral() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const v = 'abc'.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int v = 'abc'.length;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic v = 'abc'.length;
+''');
+ }
}
test_const_length_ofTopLevelVariable() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const String S = 'abc';
const v = S.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const String S = 'abc';
+const int v = S.length;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const String S = 'abc';
+const dynamic v = S.length;
+''');
+ }
}
test_const_length_ofTopLevelVariable_imported() {
@@ -2018,10 +3955,25 @@
r'''
const String S = 'abc';
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const v = S.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const int v = S.length;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic v = S.length;
+''');
+ }
}
test_const_length_ofTopLevelVariable_imported_withPrefix() {
@@ -2030,51 +3982,144 @@
r'''
const String S = 'abc';
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const v = p.S.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const int v = p.S.length;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic v = p.S.length;
+''');
+ }
}
test_const_length_staticMethod() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
static int length() => 42;
}
const v = C.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int length() {}
+}
+const () → int v = C.length;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int length() {}
+}
+const dynamic v = C.length;
+''');
+ }
}
test_const_parameterDefaultValue_initializingFormal_functionTyped() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
final x;
const C({this.x: foo});
}
int foo() => 42;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C({dynamic this.x});
+}
+int foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C({dynamic this.x});
+}
+int foo() {}
+''');
+ }
}
test_const_parameterDefaultValue_initializingFormal_named() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
final x;
const C({this.x: 1 + 2});
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C({dynamic this.x});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C({dynamic this.x});
+}
+''');
+ }
}
test_const_parameterDefaultValue_initializingFormal_positional() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
final x;
const C([this.x = 1 + 2]);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C([dynamic this.x]);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C([dynamic this.x]);
+}
+''');
+ }
}
test_const_parameterDefaultValue_normal() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
const C.positional([p = 1 + 2]);
const C.named({p: 1 + 2});
@@ -2084,15 +4129,61 @@
void methodNamedWithoutDefault({p}) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C.positional([dynamic p = 1 + 2]);
+ const C.named({dynamic p: 1 + 2});
+ void methodPositional([dynamic p = 1 + 2]) {}
+ void methodPositionalWithoutDefault([dynamic p]) {}
+ void methodNamed({dynamic p: 1 + 2}) {}
+ void methodNamedWithoutDefault({dynamic p}) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C.positional([dynamic p = 1 + 2]);
+ const C.named({dynamic p: 1 + 2});
+ void methodPositional([dynamic p = 1 + 2]) {}
+ void methodPositionalWithoutDefault([dynamic p]) {}
+ void methodNamed({dynamic p: 1 + 2}) {}
+ void methodNamedWithoutDefault({dynamic p}) {}
+}
+''');
+ }
}
test_const_reference_staticField() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
static const int F = 42;
}
const V = C.F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int F = 42;
+}
+const int V = C.F;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int F = 42;
+}
+const dynamic V = C.F;
+''');
+ }
}
test_const_reference_staticField_imported() {
@@ -2103,10 +4194,25 @@
static const int F = 42;
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = C.F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const int V = C.F;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic V = C.F;
+''');
+ }
}
test_const_reference_staticField_imported_withPrefix() {
@@ -2117,19 +4223,53 @@
static const int F = 42;
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = p.C.F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const int V = p.C.F;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = p.C.F;
+''');
+ }
}
test_const_reference_staticMethod() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
static int m(int a, String b) => 42;
}
const V = C.m;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int m(int a, String b) {}
+}
+const (int, String) → int V = C.m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int m(int a, String b) {}
+}
+const dynamic V = C.m;
+''');
+ }
}
test_const_reference_staticMethod_imported() {
@@ -2140,10 +4280,25 @@
static int m(int a, String b) => 42;
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = C.m;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const (int, String) → int V = C.m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic V = C.m;
+''');
+ }
}
test_const_reference_staticMethod_imported_withPrefix() {
@@ -2154,17 +4309,47 @@
static int m(int a, String b) => 42;
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = p.C.m;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const (int, String) → int V = p.C.m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = p.C.m;
+''');
+ }
}
test_const_reference_topLevelFunction() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
foo() {}
const V = foo;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const () → dynamic V = foo;
+dynamic foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = foo;
+dynamic foo() {}
+''');
+ }
}
test_const_reference_topLevelFunction_imported() {
@@ -2173,10 +4358,25 @@
r'''
foo() {}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = foo;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const () → dynamic V = foo;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic V = foo;
+''');
+ }
}
test_const_reference_topLevelFunction_imported_withPrefix() {
@@ -2185,17 +4385,47 @@
r'''
foo() {}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = p.foo;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const () → dynamic V = p.foo;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic V = p.foo;
+''');
+ }
}
test_const_reference_topLevelVariable() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const A = 1;
const B = A + 2;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int A = 1;
+const int B = A + 2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic A = 1;
+const dynamic B = A + 2;
+''');
+ }
}
test_const_reference_topLevelVariable_imported() {
@@ -2204,10 +4434,25 @@
r'''
const A = 1;
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const B = A + 2;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const int B = A + 2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic B = A + 2;
+''');
+ }
}
test_const_reference_topLevelVariable_imported_withPrefix() {
@@ -2216,14 +4461,29 @@
r'''
const A = 1;
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const B = p.A + 2;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const int B = p.A + 2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic B = p.A + 2;
+''');
+ }
}
test_const_reference_type() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {}
class D<T> {}
enum E {a, b, c}
@@ -2236,15 +4496,83 @@
const vEnum = E;
const vFunctionTypeAlias = F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(int a, String b);
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E a;
+ static const E b;
+ static const E c;
+}
+class C {
+}
+class D<T> {
+}
+const Type vDynamic = dynamic;
+const Type vNull = Null;
+const Type vObject = Object;
+const Type vClass = C;
+const Type vGenericClass = D;
+const Type vEnum = E;
+const Type vFunctionTypeAlias = F;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(int a, String b);
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E a;
+ static const E b;
+ static const E c;
+}
+class C {
+}
+class D<T> {
+}
+const dynamic vDynamic = dynamic;
+const dynamic vNull = Null;
+const dynamic vObject = Object;
+const dynamic vClass = C;
+const dynamic vGenericClass = D;
+const dynamic vEnum = E;
+const dynamic vFunctionTypeAlias = F;
+''');
+ }
}
test_const_reference_type_functionType() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
typedef F();
class C {
final f = <F>[];
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F();
+class C {
+ final List<F> f = const <F>[];
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F();
+class C {
+ final dynamic f = const <F>[];
+}
+''');
+ }
}
test_const_reference_type_imported() {
@@ -2255,12 +4583,31 @@
enum E {a, b, c}
typedef F(int a, String b);
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const vClass = C;
const vEnum = E;
const vFunctionTypeAlias = F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const Type vClass = C;
+const Type vEnum = E;
+const Type vFunctionTypeAlias = F;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic vClass = C;
+const dynamic vEnum = E;
+const dynamic vFunctionTypeAlias = F;
+''');
+ }
}
test_const_reference_type_imported_withPrefix() {
@@ -2271,37 +4618,103 @@
enum E {a, b, c}
typedef F(int a, String b);
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const vClass = p.C;
const vEnum = p.E;
const vFunctionTypeAlias = p.F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const Type vClass = p.C;
+const Type vEnum = p.E;
+const Type vFunctionTypeAlias = p.F;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic vClass = p.C;
+const dynamic vEnum = p.E;
+const dynamic vFunctionTypeAlias = p.F;
+''');
+ }
}
test_const_reference_type_typeParameter() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C<T> {
final f = <T>[];
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ final List<T> f = const <T>[];
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ final dynamic f = const <T>[];
+}
+''');
+ }
}
test_const_reference_unresolved_prefix0() {
- checkLibrary(
+ var library = checkLibrary(
r'''
const V = foo;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = foo;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic V = foo;
+''');
+ }
}
test_const_reference_unresolved_prefix1() {
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {}
const v = C.foo;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+const dynamic v = C.foo;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+const dynamic v = C.foo;
+''');
+ }
}
test_const_reference_unresolved_prefix2() {
@@ -2310,16 +4723,31 @@
'''
class C {}
''');
- checkLibrary(
+ var library = checkLibrary(
r'''
import 'foo.dart' as p;
const v = p.C.foo;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as p;
+const dynamic v = p.C.foo;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as p;
+const dynamic v = p.C.foo;
+''');
+ }
}
test_const_topLevel_binary() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vEqual = 1 == 2;
const vAnd = true && false;
const vOr = false || true;
@@ -2339,28 +4767,114 @@
const vLess = 1 < 2;
const vLessEqual = 1 <= 2;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const bool vEqual = 1 == 2;
+const bool vAnd = true && false;
+const bool vOr = false || true;
+const int vBitXor = 1 ^ 2;
+const int vBitAnd = 1 & 2;
+const int vBitOr = 1 | 2;
+const int vBitShiftLeft = 1 << 2;
+const int vBitShiftRight = 1 >> 2;
+const int vAdd = 1 + 2;
+const int vSubtract = 1 - 2;
+const int vMiltiply = 1 * 2;
+const num vDivide = 1 / 2;
+const int vFloorDivide = 1 ~/ 2;
+const int vModulo = 1 % 2;
+const bool vGreater = 1 > 2;
+const bool vGreaterEqual = 1 >= 2;
+const bool vLess = 1 < 2;
+const bool vLessEqual = 1 <= 2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic vEqual = 1 == 2;
+const dynamic vAnd = true && false;
+const dynamic vOr = false || true;
+const dynamic vBitXor = 1 ^ 2;
+const dynamic vBitAnd = 1 & 2;
+const dynamic vBitOr = 1 | 2;
+const dynamic vBitShiftLeft = 1 << 2;
+const dynamic vBitShiftRight = 1 >> 2;
+const dynamic vAdd = 1 + 2;
+const dynamic vSubtract = 1 - 2;
+const dynamic vMiltiply = 1 * 2;
+const dynamic vDivide = 1 / 2;
+const dynamic vFloorDivide = 1 ~/ 2;
+const dynamic vModulo = 1 % 2;
+const dynamic vGreater = 1 > 2;
+const dynamic vGreaterEqual = 1 >= 2;
+const dynamic vLess = 1 < 2;
+const dynamic vLessEqual = 1 <= 2;
+''');
+ }
}
test_const_topLevel_conditional() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vConditional = (1 == 2) ? 11 : 22;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int vConditional = 1 == 2 ? 11 : 22;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic vConditional = 1 == 2 ? 11 : 22;
+''');
+ }
}
test_const_topLevel_identical() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vIdentical = (1 == 2) ? 11 : 22;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int vIdentical = 1 == 2 ? 11 : 22;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic vIdentical = 1 == 2 ? 11 : 22;
+''');
+ }
}
test_const_topLevel_ifNull() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vIfNull = 1 ?? 2.0;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const num vIfNull = 1 ?? 2.0;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic vIfNull = 1 ?? 2.0;
+''');
+ }
}
test_const_topLevel_literal() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vNull = null;
const vBoolFalse = false;
const vBoolTrue = true;
@@ -2372,31 +4886,107 @@
const vStringInterpolation = 'aaa ${true} ${42} bbb';
const vSymbol = #aaa.bbb.ccc;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic vNull = null;
+const bool vBoolFalse = false;
+const bool vBoolTrue = true;
+const int vInt = 1;
+const int vIntLong = 44998905507923676709665;
+const double vDouble = 2.3;
+const String vString = 'abc';
+const String vStringConcat = 'aaabbb';
+const String vStringInterpolation = 'aaa ${true} ${42} bbb';
+const Symbol vSymbol = #aaa.bbb.ccc;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic vNull = null;
+const dynamic vBoolFalse = false;
+const dynamic vBoolTrue = true;
+const dynamic vInt = 1;
+const dynamic vIntLong = 44998905507923676709665;
+const dynamic vDouble = 2.3;
+const dynamic vString = 'abc';
+const dynamic vStringConcat = 'aaabbb';
+const dynamic vStringInterpolation = 'aaa ${true} ${42} bbb';
+const dynamic vSymbol = #aaa.bbb.ccc;
+''');
+ }
}
test_const_topLevel_prefix() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vNotEqual = 1 != 2;
const vNot = !true;
const vNegate = -1;
const vComplement = ~1;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const bool vNotEqual = 1 != 2;
+const bool vNot = !true;
+const int vNegate = -1;
+const int vComplement = ~1;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic vNotEqual = 1 != 2;
+const dynamic vNot = !true;
+const dynamic vNegate = -1;
+const dynamic vComplement = ~1;
+''');
+ }
}
test_const_topLevel_super() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vSuper = super;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic vSuper = super;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic vSuper = super;
+''');
+ }
}
test_const_topLevel_this() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vThis = this;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic vThis = this;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic vThis = this;
+''');
+ }
}
test_const_topLevel_typedList() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vNull = const <Null>[];
const vDynamic = const <dynamic>[1, 2, 3];
const vInterfaceNoTypeParameters = const <int>[1, 2, 3];
@@ -2404,101 +4994,313 @@
const vInterfaceWithTypeArguments = const <List<String>>[];
const vInterfaceWithTypeArguments2 = const <Map<int, List<String>>>[];
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const List<Null> vNull = const <Null>[];
+const List<dynamic> vDynamic = const <dynamic>[1, 2, 3];
+const List<int> vInterfaceNoTypeParameters = const <int>[1, 2, 3];
+const List<List<dynamic>> vInterfaceNoTypeArguments = const <List>[];
+const List<List<String>> vInterfaceWithTypeArguments = const <List<String>>[];
+const List<Map<int, List<String>>> vInterfaceWithTypeArguments2 = const <Map<int, List<String>>>[];
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic vNull = const <Null>[];
+const dynamic vDynamic = const <dynamic>[1, 2, 3];
+const dynamic vInterfaceNoTypeParameters = const <int>[1, 2, 3];
+const dynamic vInterfaceNoTypeArguments = const <List>[];
+const dynamic vInterfaceWithTypeArguments = const <List<String>>[];
+const dynamic vInterfaceWithTypeArguments2 = const <Map<int, List<String>>>[];
+''');
+ }
}
test_const_topLevel_typedList_imported() {
addLibrarySource('/a.dart', 'class C {}');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const v = const <C>[];
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const List<C> v = const <C>[];
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const dynamic v = const <C>[];
+''');
+ }
}
test_const_topLevel_typedList_importedWithPrefix() {
addLibrarySource('/a.dart', 'class C {}');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const v = const <p.C>[];
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const List<C> v = const <C>[];
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const dynamic v = const <C>[];
+''');
+ }
}
test_const_topLevel_typedMap() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vDynamic1 = const <dynamic, int>{};
const vDynamic2 = const <int, dynamic>{};
const vInterface = const <int, String>{};
const vInterfaceWithTypeArguments = const <int, List<String>>{};
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const Map<dynamic, int> vDynamic1 = const <dynamic, int>{};
+const Map<int, dynamic> vDynamic2 = const <int, dynamic>{};
+const Map<int, String> vInterface = const <int, String>{};
+const Map<int, List<String>> vInterfaceWithTypeArguments = const <int, List<String>>{};
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic vDynamic1 = const <dynamic, int>{};
+const dynamic vDynamic2 = const <int, dynamic>{};
+const dynamic vInterface = const <int, String>{};
+const dynamic vInterfaceWithTypeArguments = const <int, List<String>>{};
+''');
+ }
}
test_const_topLevel_untypedList() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const v = const [1, 2, 3];
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const List<int> v = const [1, 2, 3];
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic v = const [1, 2, 3];
+''');
+ }
}
test_const_topLevel_untypedMap() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const v = const {0: 'aaa', 1: 'bbb', 2: 'ccc'};
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const Map<int, String> v = const {0: 'aaa', 1: 'bbb', 2: 'ccc'};
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic v = const {0: 'aaa', 1: 'bbb', 2: 'ccc'};
+''');
+ }
}
test_constExpr_pushReference_field_simpleIdentifier() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
static const a = b;
static const b = null;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const dynamic a = C.b;
+ static const dynamic b = null;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const dynamic a = C.b;
+ static const dynamic b = null;
+}
+''');
+ }
}
test_constExpr_pushReference_staticMethod_simpleIdentifier() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
static const a = m;
static m() {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const () → dynamic a = C.m;
+ static dynamic m() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const dynamic a = C.m;
+ static dynamic m() {}
+}
+''');
+ }
}
test_constructor_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
/**
* Docs
*/
C();
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ /**
+ * Docs
+ */
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ /**
+ * Docs
+ */
+ C();
+}
+''');
+ }
}
test_constructor_initializers_assertInvocation() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
const C(int x) : assert(x >= 42);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C(int x) : assert(x >= 42);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C(int x) : assert(x >= 42);
+}
+''');
+ }
}
test_constructor_initializers_assertInvocation_message() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
const C(int x) : assert(x >= 42, 'foo');
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C(int x) : assert(x >= 42, 'foo');
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C(int x) : assert(x >= 42, 'foo');
+}
+''');
+ }
}
test_constructor_initializers_field() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
final x;
const C() : x = 42;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C() : x = 42;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C() : x = 42;
+}
+''');
+ }
}
test_constructor_initializers_field_notConst() {
variablesWithNotConstInitializers.add('x');
- checkLibrary(
+ var library = checkLibrary(
'''
class C {
final x;
@@ -2507,19 +5309,59 @@
int foo() => 42;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C() : x = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C() : x = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+ }
}
test_constructor_initializers_field_withParameter() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
final x;
const C(int p) : x = 1 + p;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C(int p) : x = 1 + p;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C(int p) : x = 1 + p;
+}
+''');
+ }
}
test_constructor_initializers_superInvocation_named() {
- checkLibrary('''
+ var library = checkLibrary('''
class A {
const A.aaa(int p);
}
@@ -2527,10 +5369,33 @@
const C() : super.aaa(42);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A.aaa(int p);
+}
+class C extends A {
+ const C() : super.aaa(42);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A.aaa(int p);
+}
+class C extends A {
+ const C() : super.aaa(42);
+}
+''');
+ }
}
test_constructor_initializers_superInvocation_namedExpression() {
- checkLibrary('''
+ var library = checkLibrary('''
class A {
const A.aaa(a, {int b});
}
@@ -2538,10 +5403,33 @@
const C() : super.aaa(1, b: 2);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A.aaa(dynamic a, {int b});
+}
+class C extends A {
+ const C() : super.aaa(1, b: 2);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A.aaa(dynamic a, {int b});
+}
+class C extends A {
+ const C() : super.aaa(1, b: 2);
+}
+''');
+ }
}
test_constructor_initializers_superInvocation_unnamed() {
- checkLibrary('''
+ var library = checkLibrary('''
class A {
const A(int p);
}
@@ -2549,37 +5437,117 @@
const C.ccc() : super(42);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A(int p);
+}
+class C extends A {
+ const C.ccc() : super(42);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A(int p);
+}
+class C extends A {
+ const C.ccc() : super(42);
+}
+''');
+ }
}
test_constructor_initializers_thisInvocation_named() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
const C() : this.named(1, 'bbb');
const C.named(int a, String b);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C() = C.named : this.named(1, 'bbb');
+ const C.named(int a, String b);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C() = C.named : this.named(1, 'bbb');
+ const C.named(int a, String b);
+}
+''');
+ }
}
test_constructor_initializers_thisInvocation_namedExpression() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
const C() : this.named(1, b: 2);
const C.named(a, {int b});
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C() = C.named : this.named(1, b: 2);
+ const C.named(dynamic a, {int b});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C() = C.named : this.named(1, b: 2);
+ const C.named(dynamic a, {int b});
+}
+''');
+ }
}
test_constructor_initializers_thisInvocation_unnamed() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
const C.named() : this(1, 'bbb');
const C(int a, String b);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C.named() = C : this(1, 'bbb');
+ const C(int a, String b);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ const C.named() = C : this(1, 'bbb');
+ const C(int a, String b);
+}
+''');
+ }
}
test_constructor_redirected_factory_named() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
factory C() = D.named;
C._();
@@ -2588,10 +5556,35 @@
D.named() : super._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ factory C() = D.named;
+ C._();
+}
+class D extends C {
+ D.named();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ factory C() = D.named;
+ C._();
+}
+class D extends C {
+ D.named();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_generic() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
factory C() = D<U, T>.named;
C._();
@@ -2600,6 +5593,31 @@
D.named() : super._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ factory C() = D<U, T>.named;
+ C._();
+}
+class D<T, U> extends C<U, T> {
+ D.named();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ factory C() = D<U, T>.named;
+ C._();
+}
+class D<T, U> extends C<U, T> {
+ D.named();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_imported() {
@@ -2611,13 +5629,34 @@
D.named() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart';
class C {
factory C() = D.named;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C {
+ factory C() = D.named;
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C {
+ factory C() = D.named;
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_imported_generic() {
@@ -2629,13 +5668,34 @@
D.named() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart';
class C<T, U> {
factory C() = D<U, T>.named;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C<T, U> {
+ factory C() = D<U, T>.named;
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C<T, U> {
+ factory C() = D<U, T>.named;
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_prefixed() {
@@ -2647,13 +5707,34 @@
D.named() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart' as foo;
class C {
factory C() = foo.D.named;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+ factory C() = D.named;
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+ factory C() = D.named;
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_prefixed_generic() {
@@ -2665,27 +5746,65 @@
D.named() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart' as foo;
class C<T, U> {
factory C() = foo.D<U, T>.named;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+ factory C() = D<U, T>.named;
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+ factory C() = D<U, T>.named;
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_unresolved_class() {
- checkLibrary(
+ var library = checkLibrary(
'''
class C<E> {
factory C() = D.named<E>;
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<E> {
+ factory C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<E> {
+ factory C();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_unresolved_constructor() {
- checkLibrary(
+ var library = checkLibrary(
'''
class D {}
class C<E> {
@@ -2693,10 +5812,31 @@
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class D {
+}
+class C<E> {
+ factory C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class D {
+}
+class C<E> {
+ factory C();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
factory C() = D;
C._();
@@ -2705,10 +5845,35 @@
D() : super._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ factory C() = D;
+ C._();
+}
+class D extends C {
+ D();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ factory C() = D;
+ C._();
+}
+class D extends C {
+ D();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed_generic() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
factory C() = D<U, T>;
C._();
@@ -2717,6 +5882,31 @@
D() : super._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ factory C() = D<U, T>;
+ C._();
+}
+class D<T, U> extends C<U, T> {
+ D();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ factory C() = D<U, T>;
+ C._();
+}
+class D<T, U> extends C<U, T> {
+ D();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed_imported() {
@@ -2728,13 +5918,34 @@
D() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart';
class C {
factory C() = D;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C {
+ factory C() = D;
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C {
+ factory C() = D;
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed_imported_generic() {
@@ -2746,13 +5957,34 @@
D() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart';
class C<T, U> {
factory C() = D<U, T>;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C<T, U> {
+ factory C() = D<U, T>;
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C<T, U> {
+ factory C() = D<U, T>;
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed_prefixed() {
@@ -2764,13 +5996,34 @@
D() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart' as foo;
class C {
factory C() = foo.D;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+ factory C() = D;
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+ factory C() = D;
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed_prefixed_generic() {
@@ -2782,63 +6035,177 @@
D() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart' as foo;
class C<T, U> {
factory C() = foo.D<U, T>;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+ factory C() = D<U, T>;
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+ factory C() = D<U, T>;
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed_unresolved() {
- checkLibrary(
+ var library = checkLibrary(
'''
class C<E> {
factory C() = D<E>;
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<E> {
+ factory C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<E> {
+ factory C();
+}
+''');
+ }
}
test_constructor_redirected_thisInvocation_named() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
C.named();
C() : this.named();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.named();
+ C() = C.named;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.named();
+ C() = C.named;
+}
+''');
+ }
}
test_constructor_redirected_thisInvocation_named_generic() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T> {
C.named();
C() : this.named();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ C.named();
+ C() = C<T>.named;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ C.named();
+ C() = C<T>.named;
+}
+''');
+ }
}
test_constructor_redirected_thisInvocation_unnamed() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
C();
C.named() : this();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C.named() = C;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C.named() = C;
+}
+''');
+ }
}
test_constructor_redirected_thisInvocation_unnamed_generic() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T> {
C();
C.named() : this();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ C();
+ C.named() = C<T>;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ C();
+ C.named() = C<T>;
+}
+''');
+ }
}
test_constructor_withCycles_const() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
final x;
const C() : x = const D();
@@ -2848,10 +6215,37 @@
const D() : x = const C();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C() : x = const D();
+}
+class D {
+ final dynamic x;
+ const D() : x = const C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ const C() : x = const D();
+}
+class D {
+ final dynamic x;
+ const D() : x = const C();
+}
+''');
+ }
}
test_constructor_withCycles_nonConst() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
final x;
C() : x = new D();
@@ -2861,10 +6255,37 @@
D() : x = new C();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ C();
+}
+class D {
+ final dynamic x;
+ D();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x;
+ C();
+}
+class D {
+ final dynamic x;
+ D();
+}
+''');
+ }
}
test_defaultValue_refersToGenericClass_constructor() {
- checkLibrary('''
+ var library = checkLibrary('''
class B<T> {
const B();
}
@@ -2872,10 +6293,33 @@
const C([B<T> b = const B()]);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ const B();
+}
+class C<T> {
+ const C([B<T> b = const B()]);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ const B();
+}
+class C<T> {
+ const C([B<T> b = const B()]);
+}
+''');
+ }
}
test_defaultValue_refersToGenericClass_constructor2() {
- checkLibrary('''
+ var library = checkLibrary('''
abstract class A<T> {}
class B<T> implements A<T> {
const B();
@@ -2884,19 +6328,65 @@
const C([A<T> a = const B()]);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class A<T> {
+}
+class B<T> implements A<T> {
+ const B();
+}
+class C<T> implements A<Iterable<T>> {
+ const C([A<T> a = const B()]);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class A<T> {
+}
+class B<T> implements A<T> {
+ const B();
+}
+class C<T> implements A<Iterable<T>> {
+ const C([A<T> a = const B()]);
+}
+''');
+ }
}
test_defaultValue_refersToGenericClass_functionG() {
- checkLibrary('''
+ var library = checkLibrary('''
class B<T> {
const B();
}
void foo<T>([B<T> b = const B()]) {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ const B();
+}
+void foo<T>([B<T> b = const B()]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ const B();
+}
+void foo<T>([B<T> b = const B()]) {}
+''');
+ }
}
test_defaultValue_refersToGenericClass_methodG() {
- checkLibrary('''
+ var library = checkLibrary('''
class B<T> {
const B();
}
@@ -2904,10 +6394,33 @@
void foo<T>([B<T> b = const B()]) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ const B();
+}
+class C {
+ void foo<T>([B<T> b = const B()]) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ const B();
+}
+class C {
+ void foo<T>([B<T> b = const B()]) {}
+}
+''');
+ }
}
test_defaultValue_refersToGenericClass_methodG_classG() {
- checkLibrary('''
+ var library = checkLibrary('''
class B<T1, T2> {
const B();
}
@@ -2915,10 +6428,33 @@
void foo<E2>([B<E1, E2> b = const B()]) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class B<T1, T2> {
+ const B();
+}
+class C<E1> {
+ void foo<E2>([B<E1, E2> b = const B()]) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class B<T1, T2> {
+ const B();
+}
+class C<E1> {
+ void foo<E2>([B<E1, E2> b = const B()]) {}
+}
+''');
+ }
}
test_defaultValue_refersToGenericClass_methodNG() {
- checkLibrary('''
+ var library = checkLibrary('''
class B<T> {
const B();
}
@@ -2926,37 +6462,168 @@
void foo([B<T> b = const B()]) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ const B();
+}
+class C<T> {
+ void foo([B<T> b = const B()]) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ const B();
+}
+class C<T> {
+ void foo([B<T> b = const B()]) {}
+}
+''');
+ }
}
test_enum_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
enum E { v }''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+''');
+ }
}
test_enum_value_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
enum E {
/**
* Docs
*/
v
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E {
+ final int index;
+ static const List<E> values;
+ /**
+ * Docs
+ */
+ static const E v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E {
+ final int index;
+ static const List<E> values;
+ /**
+ * Docs
+ */
+ static const E v;
+}
+''');
+ }
}
test_enum_values() {
- checkLibrary('enum E { v1, v2 }');
+ var library = checkLibrary('enum E { v1, v2 }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v1;
+ static const E v2;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v1;
+ static const E v2;
+}
+''');
+ }
}
test_enums() {
- checkLibrary('enum E1 { v1 } enum E2 { v2 }');
+ var library = checkLibrary('enum E1 { v1 } enum E2 { v2 }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E1 {
+ final int index;
+ static const List<E1> values;
+ static const E1 v1;
+}
+enum E2 {
+ final int index;
+ static const List<E2> values;
+ static const E2 v2;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E1 {
+ final int index;
+ static const List<E1> values;
+ static const E1 v1;
+}
+enum E2 {
+ final int index;
+ static const List<E2> values;
+ static const E2 v2;
+}
+''');
+ }
}
test_error_extendsEnum() {
- checkLibrary('''
+ var library = checkLibrary('''
enum E {a, b, c}
class M {}
@@ -2975,24 +6642,120 @@
class D = Object with M, E;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E a;
+ static const E b;
+ static const E c;
+}
+class M {
+}
+class A {
+ dynamic foo() {}
+}
+class B implements M {
+ dynamic foo() {}
+}
+class C extends Object with M {
+ synthetic C();
+ dynamic foo() {}
+}
+class alias D extends Object with M {
+ synthetic D() = Object;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E a;
+ static const E b;
+ static const E c;
+}
+class M {
+}
+class A {
+ dynamic foo() {}
+}
+class B implements M {
+ dynamic foo() {}
+}
+class C extends Object with M {
+ synthetic C();
+ dynamic foo() {}
+}
+class alias D extends Object with M {
+ synthetic D() = Object;
+}
+''');
+ }
}
test_executable_parameter_type_typedef() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
typedef F(int p);
main(F f) {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(int p);
+dynamic main(F f) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(int p);
+dynamic main(F f) {}
+''');
+ }
}
test_export_class() {
addLibrarySource('/a.dart', 'class C {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_class_type_alias() {
addLibrarySource(
'/a.dart', 'class C {} exends _D with _E; class _D {} class _E {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_configurations_useDefault() {
@@ -3005,6 +6768,19 @@
if (dart.library.io) 'foo_io.dart'
if (dart.library.html) 'foo_html.dart';
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'foo.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'foo.dart';
+''');
+ }
expect(library.exports[0].uri, 'foo.dart');
expect(library.exports[0].exportedLibrary.source.shortName, 'foo.dart');
}
@@ -3020,6 +6796,19 @@
if (dart.library.io) 'foo_io.dart'
if (dart.library.html) 'foo_html.dart';
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'foo_io.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'foo_io.dart';
+''');
+ }
expect(library.exports[0].uri, 'foo_io.dart');
expect(library.exports[0].exportedLibrary.source.shortName, 'foo_io.dart');
}
@@ -3035,6 +6824,19 @@
if (dart.library.io) 'foo_io.dart'
if (dart.library.html) 'foo_html.dart';
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'foo_html.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'foo_html.dart';
+''');
+ }
ExportElement export = library.exports[0];
expect(export.uri, 'foo_html.dart');
expect(export.exportedLibrary.source.shortName, 'foo_html.dart');
@@ -3042,52 +6844,182 @@
test_export_function() {
addLibrarySource('/a.dart', 'f() {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_getter() {
addLibrarySource('/a.dart', 'get f() => null;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_hide() {
addLibrary('dart:async');
- checkLibrary('export "dart:async" hide Stream, Future;');
+ var library = checkLibrary('export "dart:async" hide Stream, Future;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' hide Stream, Future;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' hide Stream, Future;
+''');
+ }
}
test_export_multiple_combinators() {
addLibrary('dart:async');
- checkLibrary('export "dart:async" hide Stream show Future;');
+ var library = checkLibrary('export "dart:async" hide Stream show Future;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' hide Stream show Future;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' hide Stream show Future;
+''');
+ }
}
test_export_setter() {
addLibrarySource('/a.dart', 'void set f(value) {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_show() {
addLibrary('dart:async');
- checkLibrary('export "dart:async" show Future, Stream;');
+ var library = checkLibrary('export "dart:async" show Future, Stream;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' show Future, Stream;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' show Future, Stream;
+''');
+ }
}
test_export_typedef() {
addLibrarySource('/a.dart', 'typedef F();');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_variable() {
addLibrarySource('/a.dart', 'var x;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_variable_const() {
addLibrarySource('/a.dart', 'const x = 0;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_variable_final() {
addLibrarySource('/a.dart', 'final x = 0;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_exportImport_configurations_useDefault() {
@@ -3106,6 +7038,23 @@
import 'bar.dart';
class B extends A {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+ }
var typeA = library.definingCompilationUnit.getType('B').supertype;
expect(typeA.element.source.shortName, 'foo.dart');
}
@@ -3127,6 +7076,23 @@
import 'bar.dart';
class B extends A {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+ }
var typeA = library.definingCompilationUnit.getType('B').supertype;
expect(typeA.element.source.shortName, 'foo_io.dart');
}
@@ -3134,215 +7100,849 @@
test_exports() {
addLibrarySource('/a.dart', 'library a;');
addLibrarySource('/b.dart', 'library b;');
- checkLibrary('export "a.dart"; export "b.dart";');
+ var library = checkLibrary('export "a.dart"; export "b.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+export 'b.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+export 'b.dart';
+''');
+ }
}
test_expr_invalid_typeParameter_asPrefix() {
variablesWithNotConstInitializers.add('f');
- checkLibrary('''
+ var library = checkLibrary('''
class C<T> {
final f = T.k;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ final dynamic f = $$invalidConstExpr$$;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ final dynamic f = $$invalidConstExpr$$;
+}
+''');
+ }
}
test_field_covariant() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
covariant int x;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ covariant int x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ covariant int x;
+}
+''');
+ }
}
test_field_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
/**
* Docs
*/
var x;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ /**
+ * Docs
+ */
+ dynamic x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ /**
+ * Docs
+ */
+ dynamic x;
+}
+''');
+ }
}
test_field_formal_param_inferred_type_implicit() {
- checkLibrary('class C extends D { var v; C(this.v); }'
+ var library = checkLibrary('class C extends D { var v; C(this.v); }'
' abstract class D { int get v; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ int v;
+ C(int this.v);
+}
+abstract class D {
+ int get v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ dynamic v;
+ C(dynamic this.v);
+}
+abstract class D {
+ int get v;
+}
+''');
+ }
}
test_field_inferred_type_nonStatic_explicit_initialized() {
- checkLibrary('class C { num v = 0; }');
+ var library = checkLibrary('class C { num v = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num v;
+}
+''');
+ }
}
test_field_inferred_type_nonStatic_implicit_initialized() {
- checkLibrary('class C { var v = 0; }');
+ var library = checkLibrary('class C { var v = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic v;
+}
+''');
+ }
}
test_field_inferred_type_nonStatic_implicit_uninitialized() {
- checkLibrary(
+ var library = checkLibrary(
'class C extends D { var v; } abstract class D { int get v; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ int v;
+}
+abstract class D {
+ int get v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ dynamic v;
+}
+abstract class D {
+ int get v;
+}
+''');
+ }
}
test_field_inferred_type_static_implicit_initialized() {
- checkLibrary('class C { static var v = 0; }');
+ var library = checkLibrary('class C { static var v = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static dynamic v;
+}
+''');
+ }
}
test_field_propagatedType_const_noDep() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
static const x = 0;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int x = 0;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const dynamic x = 0;
+}
+''');
+ }
}
test_field_propagatedType_final_dep_inLib() {
addLibrarySource('/a.dart', 'final a = 1;');
- checkLibrary('''
+ var library = checkLibrary('''
import "a.dart";
class C {
final b = a / 2;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class C {
+ final num b = a / 2;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class C {
+ final dynamic b = a / 2;
+}
+''');
+ }
}
test_field_propagatedType_final_dep_inPart() {
addSource('/a.dart', 'part of lib; final a = 1;');
- checkLibrary('''
+ var library = checkLibrary('''
library lib;
part "a.dart";
class C {
final b = a / 2;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+class C {
+ final num b = a / 2;
+}
+--------------------
+unit: a.dart
+
+final int a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+class C {
+ final dynamic b = a / 2;
+}
+--------------------
+unit: a.dart
+
+final dynamic a;
+''');
+ }
}
test_field_propagatedType_final_noDep_instance() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
final x = 0;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final int x = 0;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final dynamic x = 0;
+}
+''');
+ }
}
test_field_propagatedType_final_noDep_static() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
static final x = 0;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static final int x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static final dynamic x;
+}
+''');
+ }
}
test_field_static_final_untyped() {
- checkLibrary('class C { static final x = 0; }');
+ var library = checkLibrary('class C { static final x = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static final int x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static final dynamic x;
+}
+''');
+ }
}
test_field_untyped() {
- checkLibrary('class C { var x = 0; }');
+ var library = checkLibrary('class C { var x = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+}
+''');
+ }
}
test_function_async() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
Future f() async {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+Future<dynamic> f() async {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+Future<dynamic> f() async {}
+''');
+ }
}
test_function_asyncStar() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
Stream f() async* {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+Stream<dynamic> f() async* {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+Stream<dynamic> f() async* {}
+''');
+ }
}
test_function_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
f() {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+''');
+ }
}
test_function_entry_point() {
- checkLibrary('main() {}');
+ var library = checkLibrary('main() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic main() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic main() {}
+''');
+ }
}
test_function_entry_point_in_export() {
addLibrarySource('/a.dart', 'library a; main() {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_function_entry_point_in_export_hidden() {
addLibrarySource('/a.dart', 'library a; main() {}');
- checkLibrary('export "a.dart" hide main;');
+ var library = checkLibrary('export "a.dart" hide main;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart' hide main;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart' hide main;
+''');
+ }
}
test_function_entry_point_in_part() {
addSource('/a.dart', 'part of my.lib; main() {}');
- checkLibrary('library my.lib; part "a.dart";');
+ var library = checkLibrary('library my.lib; part "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+dynamic main() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+dynamic main() {}
+''');
+ }
}
test_function_external() {
- checkLibrary('external f();');
+ var library = checkLibrary('external f();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+external dynamic f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+external dynamic f() {}
+''');
+ }
}
test_function_parameter_final() {
- checkLibrary('f(final x) {}');
+ var library = checkLibrary('f(final x) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f(final dynamic x) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f(final dynamic x) {}
+''');
+ }
}
test_function_parameter_kind_named() {
- checkLibrary('f({x}) {}');
+ var library = checkLibrary('f({x}) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f({dynamic x}) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f({dynamic x}) {}
+''');
+ }
}
test_function_parameter_kind_positional() {
- checkLibrary('f([x]) {}');
+ var library = checkLibrary('f([x]) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f([dynamic x]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f([dynamic x]) {}
+''');
+ }
}
test_function_parameter_kind_required() {
- checkLibrary('f(x) {}');
+ var library = checkLibrary('f(x) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f(dynamic x) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f(dynamic x) {}
+''');
+ }
}
test_function_parameter_parameters() {
- checkLibrary('f(g(x, y)) {}');
+ var library = checkLibrary('f(g(x, y)) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f((dynamic, dynamic) → dynamic g) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f((dynamic, dynamic) → dynamic g) {}
+''');
+ }
}
test_function_parameter_return_type() {
- checkLibrary('f(int g()) {}');
+ var library = checkLibrary('f(int g()) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f(() → int g) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f(() → int g) {}
+''');
+ }
}
test_function_parameter_return_type_void() {
- checkLibrary('f(void g()) {}');
+ var library = checkLibrary('f(void g()) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f(() → void g) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f(() → void g) {}
+''');
+ }
}
test_function_parameter_type() {
- checkLibrary('f(int i) {}');
+ var library = checkLibrary('f(int i) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f(int i) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f(int i) {}
+''');
+ }
}
test_function_parameters() {
- checkLibrary('f(x, y) {}');
+ var library = checkLibrary('f(x, y) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f(dynamic x, dynamic y) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f(dynamic x, dynamic y) {}
+''');
+ }
}
test_function_return_type() {
- checkLibrary('int f() => null;');
+ var library = checkLibrary('int f() => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+int f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+int f() {}
+''');
+ }
}
test_function_return_type_implicit() {
- checkLibrary('f() => null;');
+ var library = checkLibrary('f() => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+''');
+ }
}
test_function_return_type_void() {
- checkLibrary('void f() {}');
+ var library = checkLibrary('void f() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ }
}
test_function_type_parameter() {
prepareAnalysisContext(createOptions());
- checkLibrary('T f<T, U>(U u) => null;');
+ var library = checkLibrary('T f<T, U>(U u) => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+T f<T, U>(U u) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+T f<T, U>(U u) {}
+''');
+ }
}
test_function_type_parameter_with_function_typed_parameter() {
prepareAnalysisContext(createOptions());
- checkLibrary('void f<T, U>(T x(U u)) {}');
+ var library = checkLibrary('void f<T, U>(T x(U u)) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>((U) → T x) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>((U) → T x) {}
+''');
+ }
}
test_functions() {
- checkLibrary('f() {} g() {}');
+ var library = checkLibrary('f() {} g() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+dynamic g() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+dynamic g() {}
+''');
+ }
}
test_futureOr() {
var library = checkLibrary('import "dart:async"; FutureOr<int> x;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+FutureOr<int> x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+dynamic x;
+''');
+ }
var variables = library.definingCompilationUnit.topLevelVariables;
expect(variables, hasLength(1));
if (createOptions().strongMode) {
@@ -3354,6 +7954,21 @@
test_futureOr_const() {
var library = checkLibrary('import "dart:async"; const x = FutureOr;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+const Type x = FutureOr;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+const dynamic x = FutureOr;
+''');
+ }
var variables = library.definingCompilationUnit.topLevelVariables;
expect(variables, hasLength(1));
var x = variables[0] as ConstTopLevelVariableElementImpl;
@@ -3372,6 +7987,25 @@
var x = f();
var y = x.then((z) => z.asDouble());
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+FutureOr<int> x;
+dynamic y;
+FutureOr<int> f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+dynamic x;
+dynamic y;
+dynamic f() {}
+''');
+ }
var variables = library.definingCompilationUnit.topLevelVariables;
expect(variables, hasLength(2));
var x = variables[0];
@@ -3389,7 +8023,7 @@
test_generic_gClass_gMethodStatic() {
prepareAnalysisContext(createOptions());
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
static void m<V, W>(V v, W w) {
void f<X, Y>(V v, W w, X x, Y y) {
@@ -3397,6 +8031,23 @@
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ static void m<V, W>(V v, W w) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ static void m<V, W>(V v, W w) {}
+}
+''');
+ }
}
test_getElement_constructor_named() {
@@ -3482,33 +8133,133 @@
}
test_getter_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
get x => null;''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+dynamic get x {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+dynamic get x {}
+''');
+ }
}
test_getter_external() {
- checkLibrary('external int get x;');
+ var library = checkLibrary('external int get x;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+external int get x {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+external int get x {}
+''');
+ }
}
test_getter_inferred_type_nonStatic_implicit_return() {
- checkLibrary(
+ var library = checkLibrary(
'class C extends D { get f => null; } abstract class D { int get f; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ int get f {}
+}
+abstract class D {
+ int get f;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ dynamic get f {}
+}
+abstract class D {
+ int get f;
+}
+''');
+ }
}
test_getters() {
- checkLibrary('int get x => null; get y => null;');
+ var library = checkLibrary('int get x => null; get y => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+int get x {}
+dynamic get y {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+int get x {}
+dynamic get y {}
+''');
+ }
}
test_implicitTopLevelVariable_getterFirst() {
- checkLibrary('int get x => 0; void set x(int value) {}');
+ var library = checkLibrary('int get x => 0; void set x(int value) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+int get x {}
+void set x(int value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+int get x {}
+void set x(int value) {}
+''');
+ }
}
test_implicitTopLevelVariable_setterFirst() {
- checkLibrary('void set x(int value) {} int get x => 0;');
+ var library = checkLibrary('void set x(int value) {} int get x => 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void set x(int value) {}
+int get x {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void set x(int value) {}
+int get x {}
+''');
+ }
}
test_import_configurations_useDefault() {
@@ -3523,6 +8274,23 @@
class B extends A {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class B extends A {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class B extends A {
+}
+''');
+ }
var typeA = library.definingCompilationUnit.getType('B').supertype;
expect(typeA.element.source.shortName, 'foo.dart');
}
@@ -3540,28 +8308,108 @@
class B extends A {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo_io.dart';
+class B extends A {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo_io.dart';
+class B extends A {
+}
+''');
+ }
var typeA = library.definingCompilationUnit.getType('B').supertype;
expect(typeA.element.source.shortName, 'foo_io.dart');
}
test_import_deferred() {
addLibrarySource('/a.dart', 'f() {}');
- checkLibrary('import "a.dart" deferred as p; main() { p.f(); }');
+ var library =
+ checkLibrary('import "a.dart" deferred as p; main() { p.f(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' deferred as p;
+dynamic main() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' deferred as p;
+dynamic main() {}
+''');
+ }
}
test_import_hide() {
addLibrary('dart:async');
- checkLibrary('import "dart:async" hide Stream, Completer; Future f;');
+ var library =
+ checkLibrary('import "dart:async" hide Stream, Completer; Future f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' hide Stream, Completer;
+Future<dynamic> f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' hide Stream, Completer;
+Future<dynamic> f;
+''');
+ }
}
test_import_multiple_combinators() {
addLibrary('dart:async');
- checkLibrary('import "dart:async" hide Stream show Future; Future f;');
+ var library =
+ checkLibrary('import "dart:async" hide Stream show Future; Future f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' hide Stream show Future;
+Future<dynamic> f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' hide Stream show Future;
+Future<dynamic> f;
+''');
+ }
}
test_import_prefixed() {
addLibrarySource('/a.dart', 'library a; class C {}');
- checkLibrary('import "a.dart" as a; a.C c;');
+ var library = checkLibrary('import "a.dart" as a; a.C c;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+C c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+C c;
+''');
+ }
}
test_import_self() {
@@ -3574,6 +8422,27 @@
expect(resynthesized.imports[0].importedLibrary.location,
resynthesized.location);
expect(resynthesized.imports[1].importedLibrary.isDartCore, true);
+ if (isStrongMode) {
+ checkElementText(
+ resynthesized,
+ r'''
+import 'test.dart' as p;
+class C {
+}
+class D extends C {
+}
+''');
+ } else {
+ checkElementText(
+ resynthesized,
+ r'''
+import 'test.dart' as p;
+class C {
+}
+class D extends C {
+}
+''');
+ }
}
test_import_short_absolute() {
@@ -3582,78 +8451,212 @@
var destinationPath =
resourceProvider.pathContext.fromUri(Uri.parse('/a.dart'));
addLibrarySource(destinationPath, 'class C {}');
- checkLibrary('import "/a.dart"; C c;');
+ var library = checkLibrary('import "/a.dart"; C c;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import '/a.dart';
+C c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import '/a.dart';
+C c;
+''');
+ }
}
test_import_show() {
addLibrary('dart:async');
- checkLibrary('''
+ var library = checkLibrary('''
import "dart:async" show Future, Stream;
Future f;
Stream s;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' show Future, Stream;
+Future<dynamic> f;
+Stream<dynamic> s;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' show Future, Stream;
+Future<dynamic> f;
+Stream<dynamic> s;
+''');
+ }
}
test_imports() {
addLibrarySource('/a.dart', 'library a; class C {}');
addLibrarySource('/b.dart', 'library b; class D {}');
- checkLibrary('import "a.dart"; import "b.dart"; C c; D d;');
+ var library = checkLibrary('import "a.dart"; import "b.dart"; C c; D d;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+C c;
+D d;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+C c;
+D d;
+''');
+ }
}
test_inferred_function_type_for_variable_in_generic_function() {
// In the code below, `x` has an inferred type of `() => int`, with 2
// (unused) type parameters from the enclosing top level function.
- checkLibrary('''
+ var library = checkLibrary('''
f<U, V>() {
var x = () => 0;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f<U, V>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f<U, V>() {}
+''');
+ }
}
test_inferred_function_type_in_generic_class_constructor() {
// In the code below, `() => () => 0` has an inferred return type of
// `() => int`, with 2 (unused) type parameters from the enclosing class.
- checkLibrary('''
+ var library = checkLibrary('''
class C<U, V> {
final x;
C() : x = (() => () => 0);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ final dynamic x;
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ final dynamic x;
+ C();
+}
+''');
+ }
}
test_inferred_function_type_in_generic_class_getter() {
// In the code below, `() => () => 0` has an inferred return type of
// `() => int`, with 2 (unused) type parameters from the enclosing class.
- checkLibrary('''
+ var library = checkLibrary('''
class C<U, V> {
get x => () => () => 0;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ dynamic get x {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ dynamic get x {}
+}
+''');
+ }
}
test_inferred_function_type_in_generic_class_in_generic_method() {
// In the code below, `() => () => 0` has an inferred return type of
// `() => int`, with 3 (unused) type parameters from the enclosing class
// and method.
- checkLibrary('''
+ var library = checkLibrary('''
class C<T> {
f<U, V>() {
print(() => () => 0);
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ dynamic f<U, V>() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ dynamic f<U, V>() {}
+}
+''');
+ }
}
test_inferred_function_type_in_generic_class_setter() {
// In the code below, `() => () => 0` has an inferred return type of
// `() => int`, with 2 (unused) type parameters from the enclosing class.
- checkLibrary('''
+ var library = checkLibrary('''
class C<U, V> {
void set x(value) {
print(() => () => 0);
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ void set x(dynamic value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ void set x(dynamic value) {}
+}
+''');
+ }
}
test_inferred_function_type_in_generic_closure() {
@@ -3668,11 +8671,23 @@
}
// In the code below, `<U, V>() => () => 0` has an inferred return type of
// `() => int`, with 3 (unused) type parameters.
- checkLibrary('''
+ var library = checkLibrary('''
f<T>() {
print(/*<U, V>*/() => () => 0);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f<T>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_inferred_generic_function_type_in_generic_closure() {
@@ -3687,35 +8702,136 @@
}
// In the code below, `<U, V>() => <W, X, Y, Z>() => 0` has an inferred
// return type of `() => int`, with 7 (unused) type parameters.
- checkLibrary('''
+ var library = checkLibrary('''
f<T>() {
print(/*<U, V>*/() => /*<W, X, Y, Z>*/() => 0);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f<T>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_inferred_type_is_typedef() {
- checkLibrary('typedef int F(String s);'
+ var library = checkLibrary('typedef int F(String s);'
' class C extends D { var v; }'
' abstract class D { F get v; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef int F(String s);
+class C extends D {
+ F v;
+}
+abstract class D {
+ F get v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef int F(String s);
+class C extends D {
+ dynamic v;
+}
+abstract class D {
+ F get v;
+}
+''');
+ }
}
test_inferred_type_refers_to_bound_type_param() {
- checkLibrary('class C<T> extends D<int, T> { var v; }'
+ var library = checkLibrary('class C<T> extends D<int, T> { var v; }'
' abstract class D<U, V> { Map<V, U> get v; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> extends D<int, T> {
+ Map<T, int> v;
+}
+abstract class D<U, V> {
+ Map<V, U> get v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> extends D<int, T> {
+ dynamic v;
+}
+abstract class D<U, V> {
+ Map<V, U> get v;
+}
+''');
+ }
}
void test_inferred_type_refers_to_function_typed_param_of_typedef() {
- checkLibrary('''
+ var library = checkLibrary('''
typedef void F(int g(String s));
h(F f) => null;
var v = h(/*info:INFERRED_TYPE_CLOSURE*/(y) {});
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef void F((String) → int g);
+dynamic v;
+dynamic h(F f) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef void F((String) → int g);
+dynamic v;
+dynamic h(F f) {}
+''');
+ }
}
test_inferred_type_refers_to_function_typed_parameter_type_generic_class() {
- checkLibrary('class C<T, U> extends D<U, int> { void f(int x, g) {} }'
- ' abstract class D<V, W> { void f(int x, W g(V s)); }');
+ var library =
+ checkLibrary('class C<T, U> extends D<U, int> { void f(int x, g) {} }'
+ ' abstract class D<V, W> { void f(int x, W g(V s)); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> extends D<U, int> {
+ void f(int x, (U) → int g) {}
+}
+abstract class D<V, W> {
+ void f(int x, (V) → W g);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> extends D<U, int> {
+ void f(int x, dynamic g) {}
+}
+abstract class D<V, W> {
+ void f(int x, (V) → W g);
+}
+''');
+ }
}
test_inferred_type_refers_to_function_typed_parameter_type_other_lib() {
@@ -3723,31 +8839,127 @@
'/a.dart', 'import "b.dart"; abstract class D extends E {}');
addLibrarySource(
'/b.dart', 'abstract class E { void f(int x, int g(String s)); }');
- checkLibrary('import "a.dart"; class C extends D { void f(int x, g) {} }');
+ var library = checkLibrary(
+ 'import "a.dart"; class C extends D { void f(int x, g) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class C extends D {
+ void f(int x, (String) → int g) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class C extends D {
+ void f(int x, dynamic g) {}
+}
+''');
+ }
}
test_inferred_type_refers_to_method_function_typed_parameter_type() {
- checkLibrary('class C extends D { void f(int x, g) {} }'
+ var library = checkLibrary('class C extends D { void f(int x, g) {} }'
' abstract class D { void f(int x, int g(String s)); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void f(int x, (String) → int g) {}
+}
+abstract class D {
+ void f(int x, (String) → int g);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void f(int x, dynamic g) {}
+}
+abstract class D {
+ void f(int x, (String) → int g);
+}
+''');
+ }
}
test_inferred_type_refers_to_nested_function_typed_param() {
- checkLibrary('''
+ var library = checkLibrary('''
f(void g(int x, void h())) => null;
var v = f((x, y) {});
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic v;
+dynamic f((int, () → void) → void g) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic v;
+dynamic f((int, () → void) → void g) {}
+''');
+ }
}
test_inferred_type_refers_to_nested_function_typed_param_named() {
- checkLibrary('''
+ var library = checkLibrary('''
f({void g(int x, void h())}) => null;
var v = f(g: (x, y) {});
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic v;
+dynamic f({(int, () → void) → void g}) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic v;
+dynamic f({(int, () → void) → void g}) {}
+''');
+ }
}
test_inferred_type_refers_to_setter_function_typed_parameter_type() {
- checkLibrary('class C extends D { void set f(g) {} }'
+ var library = checkLibrary('class C extends D { void set f(g) {} }'
' abstract class D { void set f(int g(String s)); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void set f((String) → int g) {}
+}
+abstract class D {
+ void set f((String) → int g);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void set f(dynamic g) {}
+}
+abstract class D {
+ void set f((String) → int g);
+}
+''');
+ }
}
void test_inferredType_definedInSdkLibraryPart() {
@@ -3765,6 +8977,25 @@
m(p) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class B extends A {
+ dynamic m(Stream<dynamic> p) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class B extends A {
+ dynamic m(dynamic p) {}
+}
+''');
+ }
ClassElement b = library.definingCompilationUnit.types[0];
ParameterElement p = b.methods[0].parameters[0];
// This test should verify that we correctly record inferred types,
@@ -3777,15 +9008,32 @@
}
void test_inferredType_usesSyntheticFunctionType_functionTypedParam() {
- checkLibrary('''
+ var library = checkLibrary('''
int f(int x(String y)) => null;
String g(int x(String y)) => null;
var v = [f, g];
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+List<((String) → int) → Object> v;
+int f((String) → int x) {}
+String g((String) → int x) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic v;
+int f((String) → int x) {}
+String g((String) → int x) {}
+''');
+ }
}
test_inheritance_errors() {
- checkLibrary('''
+ var library = checkLibrary('''
abstract class A {
int m();
}
@@ -3800,63 +9048,214 @@
var f;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class A {
+ int m();
+}
+abstract class B {
+ String m();
+}
+abstract class C implements A, B {
+}
+abstract class D extends C {
+ dynamic f;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class A {
+ int m();
+}
+abstract class B {
+ String m();
+}
+abstract class C implements A, B {
+}
+abstract class D extends C {
+ dynamic f;
+}
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure() {
- checkLibrary('var v = () => 0;');
+ var library = checkLibrary('var v = () => 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+() → int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic v;
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_await_dynamic() {
- checkLibrary('var v = (f) async => await f;');
+ var library = checkLibrary('var v = (f) async => await f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+(dynamic) → Future<dynamic> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic v;
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_await_future3_int() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
var v = (Future<Future<Future<int>>> f) async => await f;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+(Future<Future<Future<int>>>) → Future<int> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+dynamic v;
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_await_future_int() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
var v = (Future<int> f) async => await f;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+(Future<int>) → Future<int> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+dynamic v;
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_await_future_noArg() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
var v = (Future f) async => await f;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+(Future<dynamic>) → Future<dynamic> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+dynamic v;
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_field() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
var v = () => 0;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ () → int v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic v;
+}
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_local() {
- checkLibrary('''
+ var library = checkLibrary('''
void f() {
int u = 0;
var v = () => 0;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ }
}
test_instantiateToBounds_boundRefersToEarlierTypeArgument() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<S extends num, T extends C<S, T>> {}
C c;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<S extends num, T extends C<S, T>> {
+}
+C<num, C<num, dynamic>> c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<S extends num, T extends C<S, T>> {
+}
+C<dynamic, dynamic> c;
+''');
+ }
}
test_instantiateToBounds_boundRefersToItself() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T extends C<T>> {}
C c;
var c2 = new C();
@@ -3864,27 +9263,101 @@
var c3 = new C();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends C<T>> {
+}
+class B {
+ C<C<dynamic>> c3;
+}
+C<C<dynamic>> c;
+C<C<dynamic>> c2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends C<T>> {
+}
+class B {
+ dynamic c3;
+}
+C<dynamic> c;
+dynamic c2;
+''');
+ }
}
test_instantiateToBounds_boundRefersToLaterTypeArgument() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T extends C<T, U>, U extends num> {}
C c;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends C<T, U>, U extends num> {
+}
+C<C<dynamic, num>, num> c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends C<T, U>, U extends num> {
+}
+C<dynamic, dynamic> c;
+''');
+ }
}
test_instantiateToBounds_functionTypeAlias_simple() {
- checkLibrary('''
+ var library = checkLibrary('''
typedef F<T extends num>(T p);
F f;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F<T extends num>(T p);
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F<T extends num>(T p);
+F f;
+''');
+ }
}
test_instantiateToBounds_simple() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T extends num> {}
C c;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends num> {
+}
+C<num> c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends num> {
+}
+C<dynamic> c;
+''');
+ }
}
test_invalid_annotation_prefixed_constructor() {
@@ -3895,11 +9368,30 @@
const C.named();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import "a.dart" as a;
@a.C.named
class D {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+@a.C.named
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+@a.C.named
+class D {
+}
+''');
+ }
}
test_invalid_annotation_unprefixed_constructor() {
@@ -3910,31 +9402,86 @@
const C.named();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import "a.dart";
@C.named
class D {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+@C.named
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+@C.named
+class D {
+}
+''');
+ }
}
test_invalid_importPrefix_asTypeArgument() {
- checkLibrary('''
+ var library = checkLibrary('''
import 'dart:async' as ppp;
class C {
List<ppp> v;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as ppp;
+class C {
+ List<dynamic> v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as ppp;
+class C {
+ List<dynamic> v;
+}
+''');
+ }
}
test_invalid_nameConflict_imported() {
namesThatCannotBeResolved.add('V');
addLibrarySource('/a.dart', 'V() {}');
addLibrarySource('/b.dart', 'V() {}');
- checkLibrary('''
+ var library = checkLibrary('''
import 'a.dart';
import 'b.dart';
foo([p = V]) {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+dynamic foo([dynamic p = V]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+dynamic foo([dynamic p = V]) {}
+''');
+ }
}
test_invalid_nameConflict_imported_exported() {
@@ -3947,41 +9494,109 @@
export 'a.dart';
export 'b.dart';
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'c.dart';
foo([p = V]) {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+dynamic foo([dynamic p = V]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+dynamic foo([dynamic p = V]) {}
+''');
+ }
}
test_invalid_nameConflict_local() {
namesThatCannotBeResolved.add('V');
- checkLibrary('''
+ var library = checkLibrary('''
foo([p = V]) {}
V() {}
var V;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic V;
+dynamic foo([dynamic p = V]) {}
+dynamic V() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic V;
+dynamic foo([dynamic p = V]) {}
+dynamic V() {}
+''');
+ }
}
test_invalid_setterParameter_fieldFormalParameter() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
int foo;
void set bar(this.foo) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int foo;
+ void set bar(dynamic this.foo) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int foo;
+ void set bar(dynamic this.foo) {}
+}
+''');
+ }
}
test_invalid_setterParameter_fieldFormalParameter_self() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
set x(this.x) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(dynamic this.x) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic set x(dynamic this.x) {}
+}
+''');
+ }
}
test_invalidUris() {
allowMissingFiles = true;
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import '[invalid uri]';
import '[invalid uri]:foo.dart';
import 'a1.dart';
@@ -3998,31 +9613,104 @@
part 'a3.dart';
part '[invalid uri]';
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a1.dart';
+export 'a2.dart';
+part 'a3.dart';
+--------------------
+unit: a3.dart
+
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a1.dart';
+export 'a2.dart';
+part 'a3.dart';
+--------------------
+unit: a3.dart
+
+''');
+ }
}
test_library() {
- checkLibrary('');
+ var library = checkLibrary('');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_library_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
library foo;''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library foo;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library foo;
+''');
+ }
}
test_library_name_with_spaces() {
- checkLibrary('library foo . bar ;');
+ var library = checkLibrary('library foo . bar ;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library foo.bar;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library foo.bar;
+''');
+ }
}
test_library_named() {
- checkLibrary('library foo.bar;');
+ var library = checkLibrary('library foo.bar;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library foo.bar;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library foo.bar;
+''');
+ }
}
test_localFunctions() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
f() {
f1() {}
{
@@ -4030,38 +9718,98 @@
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+''');
+ }
}
test_localFunctions_inConstructor() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
C() {
f() {}
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_localFunctions_inMethod() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
m() {
f() {}
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic m() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic m() {}
+}
+''');
+ }
}
test_localFunctions_inTopLevelGetter() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
get g {
f() {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic get g {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic get g {}
+''');
+ }
}
test_localLabels_inConstructor() {
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {
C() {
@@ -4074,10 +9822,27 @@
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_localLabels_inMethod() {
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {
m() {
@@ -4090,10 +9855,27 @@
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic m() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic m() {}
+}
+''');
+ }
}
test_localLabels_inTopLevelFunction() {
- checkLibrary(
+ var library = checkLibrary(
r'''
main() {
aaa: while (true) {}
@@ -4104,10 +9886,23 @@
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic main() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic main() {}
+''');
+ }
}
test_localVariables_inConstructor() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
C() {
int v;
@@ -4115,10 +9910,27 @@
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_localVariables_inLocalFunction() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
f() {
f1() {
int v1 = 1;
@@ -4131,20 +9943,50 @@
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+''');
+ }
}
test_localVariables_inMethod() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
m() {
int v;
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic m() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic m() {}
+}
+''');
+ }
}
test_localVariables_inTopLevelFunction() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
main() {
int v1 = 1;
{
@@ -4153,260 +9995,1295 @@
Map<int, List<double>> v3;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic main() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic main() {}
+''');
+ }
}
test_localVariables_inTopLevelGetter() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
get g {
int v;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic get g {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic get g {}
+''');
+ }
}
test_main_class() {
- checkLibrary('class main {}');
+ var library = checkLibrary('class main {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class main {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class main {
+}
+''');
+ }
}
test_main_class_alias() {
- checkLibrary('class main = C with D; class C {} class D {}');
+ var library = checkLibrary('class main = C with D; class C {} class D {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class alias main extends C with D {
+ synthetic main() = C;
+}
+class C {
+}
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class alias main extends C with D {
+ synthetic main() = C;
+}
+class C {
+}
+class D {
+}
+''');
+ }
}
test_main_class_alias_via_export() {
addLibrarySource('/a.dart', 'class main = C with D; class C {} class D {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_main_class_via_export() {
addLibrarySource('/a.dart', 'class main {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_main_getter() {
- checkLibrary('get main => null;');
+ var library = checkLibrary('get main => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic get main {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic get main {}
+''');
+ }
}
test_main_getter_via_export() {
addLibrarySource('/a.dart', 'get main => null;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_main_typedef() {
- checkLibrary('typedef main();');
+ var library = checkLibrary('typedef main();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic main();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic main();
+''');
+ }
}
test_main_typedef_via_export() {
addLibrarySource('/a.dart', 'typedef main();');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_main_variable() {
- checkLibrary('var main;');
+ var library = checkLibrary('var main;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic main;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic main;
+''');
+ }
}
test_main_variable_via_export() {
addLibrarySource('/a.dart', 'var main;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_member_function_async() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
class C {
Future f() async {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+class C {
+ Future<dynamic> f() async {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+class C {
+ Future<dynamic> f() async {}
+}
+''');
+ }
}
test_member_function_asyncStar() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
class C {
Stream f() async* {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+class C {
+ Stream<dynamic> f() async* {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+class C {
+ Stream<dynamic> f() async* {}
+}
+''');
+ }
}
test_metadata_classDeclaration() {
- checkLibrary('const a = null; @a class C {}');
+ var library = checkLibrary(r'''
+const a = null;
+const b = null;
+@a
+@b
+class C {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@a
+@b
+class C {
+}
+const dynamic a = null;
+const dynamic b = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@a
+@b
+class C {
+}
+const dynamic a = null;
+const dynamic b = null;
+''');
+ }
}
test_metadata_classTypeAlias() {
- checkLibrary(
+ var library = checkLibrary(
'const a = null; @a class C = D with E; class D {} class E {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@a
+class alias C extends D with E {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@a
+class alias C extends D with E {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_constructor_call_named() {
- checkLibrary('class A { const A.named(); } @A.named() class C {}');
+ var library =
+ checkLibrary('class A { const A.named(); } @A.named() class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A.named();
+}
+@A.named()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A.named();
+}
+@A.named()
+class C {
+}
+''');
+ }
}
test_metadata_constructor_call_named_prefixed() {
addLibrarySource('/foo.dart', 'class A { const A.named(); }');
- checkLibrary('import "foo.dart" as foo; @foo.A.named() class C {}');
+ var library =
+ checkLibrary('import "foo.dart" as foo; @foo.A.named() class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+@A.named()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+@A.named()
+class C {
+}
+''');
+ }
}
test_metadata_constructor_call_unnamed() {
- checkLibrary('class A { const A(); } @A() class C {}');
+ var library = checkLibrary('class A { const A(); } @A() class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A();
+}
+@A()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A();
+}
+@A()
+class C {
+}
+''');
+ }
}
test_metadata_constructor_call_unnamed_prefixed() {
addLibrarySource('/foo.dart', 'class A { const A(); }');
- checkLibrary('import "foo.dart" as foo; @foo.A() class C {}');
+ var library = checkLibrary('import "foo.dart" as foo; @foo.A() class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+@A()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+@A()
+class C {
+}
+''');
+ }
}
test_metadata_constructor_call_with_args() {
- checkLibrary('class A { const A(x); } @A(null) class C {}');
+ var library = checkLibrary('class A { const A(x); } @A(null) class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A(dynamic x);
+}
+@A(null)
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A(dynamic x);
+}
+@A(null)
+class C {
+}
+''');
+ }
}
test_metadata_constructorDeclaration_named() {
- checkLibrary('const a = null; class C { @a C.named(); }');
+ var library = checkLibrary('const a = null; class C { @a C.named(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ C.named();
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ C.named();
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_constructorDeclaration_unnamed() {
- checkLibrary('const a = null; class C { @a C(); }');
+ var library = checkLibrary('const a = null; class C { @a C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ C();
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ C();
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_enumDeclaration() {
- checkLibrary('const a = null; @a enum E { v }');
+ var library = checkLibrary('const a = null; @a enum E { v }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@a
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@a
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_exportDirective() {
addLibrarySource('/foo.dart', '');
- checkLibrary('@a export "foo.dart"; const a = null;');
+ var library = checkLibrary('@a export "foo.dart"; const a = null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@a
+export 'foo.dart';
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@a
+export 'foo.dart';
+const dynamic a = null;
+''');
+ }
}
test_metadata_fieldDeclaration() {
- checkLibrary('const a = null; class C { @a int x; }');
+ var library = checkLibrary('const a = null; class C { @a int x; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ int x;
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ int x;
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_fieldFormalParameter() {
- checkLibrary('const a = null; class C { var x; C(@a this.x); }');
+ var library =
+ checkLibrary('const a = null; class C { var x; C(@a this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(@a dynamic this.x);
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C(@a dynamic this.x);
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_fieldFormalParameter_withDefault() {
- checkLibrary('const a = null; class C { var x; C([@a this.x = null]); }');
+ var library = checkLibrary(
+ 'const a = null; class C { var x; C([@a this.x = null]); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C([@a dynamic this.x]);
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C([@a dynamic this.x]);
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_functionDeclaration_function() {
- checkLibrary('const a = null; @a f() {}');
+ var library = checkLibrary('const a = null; @a f() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f() {}
+''');
+ }
}
test_metadata_functionDeclaration_getter() {
- checkLibrary('const a = null; @a get f => null;');
+ var library = checkLibrary('const a = null; @a get f => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+@a
+dynamic get f {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+@a
+dynamic get f {}
+''');
+ }
}
test_metadata_functionDeclaration_setter() {
- checkLibrary('const a = null; @a set f(value) {}');
+ var library = checkLibrary('const a = null; @a set f(value) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+@a
+void set f(dynamic value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+@a
+dynamic set f(dynamic value) {}
+''');
+ }
}
test_metadata_functionTypeAlias() {
- checkLibrary('const a = null; @a typedef F();');
+ var library = checkLibrary('const a = null; @a typedef F();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@a
+typedef dynamic F();
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@a
+typedef dynamic F();
+const dynamic a = null;
+''');
+ }
}
test_metadata_functionTypedFormalParameter() {
- checkLibrary('const a = null; f(@a g()) {}');
+ var library = checkLibrary('const a = null; f(@a g()) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f(@a () → dynamic g) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f(@a () → dynamic g) {}
+''');
+ }
}
test_metadata_functionTypedFormalParameter_withDefault() {
- checkLibrary('const a = null; f([@a g() = null]) {}');
+ var library = checkLibrary('const a = null; f([@a g() = null]) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f([@a () → dynamic g = null]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f([@a () → dynamic g = null]) {}
+''');
+ }
}
test_metadata_importDirective() {
addLibrarySource('/foo.dart', 'const b = null;');
- checkLibrary('@a import "foo.dart"; const a = b;');
+ var library = checkLibrary('@a import "foo.dart"; const a = b;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@a
+import 'foo.dart';
+const dynamic a = b;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@a
+import 'foo.dart';
+const dynamic a = b;
+''');
+ }
}
test_metadata_invalid_classDeclaration() {
- checkLibrary('f(_) {} @f(42) class C {}');
+ var library = checkLibrary('f(_) {} @f(42) class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@f(42)
+class C {
+}
+dynamic f(dynamic _) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@f(42)
+class C {
+}
+dynamic f(dynamic _) {}
+''');
+ }
}
test_metadata_libraryDirective() {
- checkLibrary('@a library L; const a = null;');
+ var library = checkLibrary('@a library L; const a = null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@a
+library L;
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@a
+library L;
+const dynamic a = null;
+''');
+ }
}
test_metadata_methodDeclaration_getter() {
- checkLibrary('const a = null; class C { @a get m => null; }');
+ var library = checkLibrary('const a = null; class C { @a get m => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ dynamic get m {}
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ dynamic get m {}
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_methodDeclaration_method() {
- checkLibrary('const a = null; class C { @a m() {} }');
+ var library = checkLibrary(r'''
+const a = null;
+const b = null;
+class C {
+ @a
+ @b
+ m() {}
+}
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ @b
+ dynamic m() {}
+}
+const dynamic a = null;
+const dynamic b = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ @b
+ dynamic m() {}
+}
+const dynamic a = null;
+const dynamic b = null;
+''');
+ }
}
test_metadata_methodDeclaration_setter() {
- checkLibrary('const a = null; class C { @a set m(value) {} }');
+ var library =
+ checkLibrary('const a = null; class C { @a set m(value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ void set m(dynamic value) {}
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ @a
+ dynamic set m(dynamic value) {}
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_partDirective() {
addSource('/foo.dart', 'part of L;');
- checkLibrary('library L; @a part "foo.dart"; const a = null;');
+ var library =
+ checkLibrary('library L; @a part "foo.dart"; const a = null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library L;
+@a
+part 'foo.dart';
+const dynamic a = null;
+--------------------
+unit: foo.dart
+
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library L;
+@a
+part 'foo.dart';
+const dynamic a = null;
+--------------------
+unit: foo.dart
+
+''');
+ }
}
test_metadata_prefixed_variable() {
addLibrarySource('/a.dart', 'const b = null;');
- checkLibrary('import "a.dart" as a; @a.b class C {}');
+ var library = checkLibrary('import "a.dart" as a; @a.b class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+@a.b
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+@a.b
+class C {
+}
+''');
+ }
}
test_metadata_simpleFormalParameter() {
- checkLibrary('const a = null; f(@a x) {}');
+ var library = checkLibrary('const a = null; f(@a x) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f(@a dynamic x) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f(@a dynamic x) {}
+''');
+ }
}
test_metadata_simpleFormalParameter_withDefault() {
- checkLibrary('const a = null; f([@a x = null]) {}');
+ var library = checkLibrary('const a = null; f([@a x = null]) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f([@a dynamic x = null]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f([@a dynamic x = null]) {}
+''');
+ }
}
test_metadata_topLevelVariableDeclaration() {
- checkLibrary('const a = null; @a int v;');
+ var library = checkLibrary('const a = null; @a int v;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+@a
+int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+@a
+int v;
+''');
+ }
}
test_metadata_typeParameter_ofClass() {
- checkLibrary('const a = null; class C<@a T> {}');
+ var library = checkLibrary('const a = null; class C<@a T> {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_typeParameter_ofClassTypeAlias() {
- checkLibrary(
+ var library = checkLibrary(
'const a = null; class C<@a T> = D with E; class D {} class E {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class alias C<T> extends D with E {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class alias C<T> extends D with E {
+ synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+const dynamic a = null;
+''');
+ }
}
test_metadata_typeParameter_ofFunction() {
- checkLibrary('const a = null; f<@a T>() {}');
+ var library = checkLibrary('const a = null; f<@a T>() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f<T>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic a = null;
+dynamic f<T>() {}
+''');
+ }
}
test_metadata_typeParameter_ofTypedef() {
- checkLibrary('const a = null; typedef F<@a T>();');
+ var library = checkLibrary('const a = null; typedef F<@a T>();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F<T>();
+const dynamic a = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F<T>();
+const dynamic a = null;
+''');
+ }
}
test_method_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
/**
* Docs
*/
f() {}
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ /**
+ * Docs
+ */
+ dynamic f() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ /**
+ * Docs
+ */
+ dynamic f() {}
+}
+''');
+ }
}
test_method_inferred_type_nonStatic_implicit_param() {
- checkLibrary('class C extends D { void f(value) {} }'
+ var library = checkLibrary('class C extends D { void f(value) {} }'
' abstract class D { void f(int value); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void f(int value) {}
+}
+abstract class D {
+ void f(int value);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void f(dynamic value) {}
+}
+abstract class D {
+ void f(int value);
+}
+''');
+ }
}
test_method_inferred_type_nonStatic_implicit_return() {
- checkLibrary(
+ var library = checkLibrary(
'class C extends D { f() => null; } abstract class D { int f(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ int f() {}
+}
+abstract class D {
+ int f();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ dynamic f() {}
+}
+abstract class D {
+ int f();
+}
+''');
+ }
}
test_method_type_parameter() {
prepareAnalysisContext(createOptions());
- checkLibrary('class C { T f<T, U>(U u) => null; }');
+ var library = checkLibrary('class C { T f<T, U>(U u) => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ T f<T, U>(U u) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ T f<T, U>(U u) {}
+}
+''');
+ }
}
test_method_type_parameter_in_generic_class() {
prepareAnalysisContext(createOptions());
- checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
+ var library =
+ checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ V f<V, W>(T t, U u, W w) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ V f<V, W>(T t, U u, W w) {}
+}
+''');
+ }
}
test_method_type_parameter_with_function_typed_parameter() {
prepareAnalysisContext(createOptions());
- checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
+ var library = checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void f<T, U>((U) → T x) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void f<T, U>((U) → T x) {}
+}
+''');
+ }
}
test_nameConflict_exportedAndLocal() {
@@ -4418,10 +11295,25 @@
export 'a.dart';
class C {}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'c.dart';
C v = null;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+C v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+C v;
+''');
+ }
}
test_nameConflict_exportedAndLocal_exported() {
@@ -4434,10 +11326,25 @@
class C {}
''');
addLibrarySource('/d.dart', 'export "c.dart";');
- checkLibrary('''
+ var library = checkLibrary('''
import 'd.dart';
C v = null;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'd.dart';
+C v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'd.dart';
+C v;
+''');
+ }
}
test_nameConflict_exportedAndParted() {
@@ -4456,10 +11363,25 @@
export 'a.dart';
part 'b.dart';
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'c.dart';
C v = null;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+C v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+C v;
+''');
+ }
}
test_nameConflict_importWithRelativeUri_exportWithAbsolute() {
@@ -4469,15 +11391,32 @@
addLibrarySource('/a.dart', 'class A {}');
addLibrarySource('/b.dart', 'export "/a.dart";');
- checkLibrary('''
+ var library = checkLibrary('''
import 'a.dart';
import 'b.dart';
A v = null;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+A v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+A v;
+''');
+ }
}
test_nested_generic_functions_in_generic_class_with_function_typed_params() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
void g<V, W>() {
void h<X, Y>(void p(T t, U u, V v, W w, X x, Y y)) {
@@ -4485,10 +11424,27 @@
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ void g<V, W>() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ void g<V, W>() {}
+}
+''');
+ }
}
test_nested_generic_functions_in_generic_class_with_local_variables() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
void g<V, W>() {
void h<X, Y>() {
@@ -4502,10 +11458,27 @@
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ void g<V, W>() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ void g<V, W>() {}
+}
+''');
+ }
}
test_nested_generic_functions_with_function_typed_param() {
- checkLibrary('''
+ var library = checkLibrary('''
void f<T, U>() {
void g<V, W>() {
void h<X, Y>(void p(T t, U u, V v, W w, X x, Y y)) {
@@ -4513,10 +11486,23 @@
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>() {}
+''');
+ }
}
test_nested_generic_functions_with_local_variables() {
- checkLibrary('''
+ var library = checkLibrary('''
void f<T, U>() {
void g<V, W>() {
void h<X, Y>() {
@@ -4530,54 +11516,211 @@
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>() {}
+''');
+ }
}
test_operator() {
- checkLibrary('class C { C operator+(C other) => null; }');
+ var library = checkLibrary('class C { C operator+(C other) => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C +(C other) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C +(C other) {}
+}
+''');
+ }
}
test_operator_equal() {
- checkLibrary('class C { bool operator==(Object other) => false; }');
+ var library =
+ checkLibrary('class C { bool operator==(Object other) => false; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool ==(Object other) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool ==(Object other) {}
+}
+''');
+ }
}
test_operator_external() {
- checkLibrary('class C { external C operator+(C other); }');
+ var library = checkLibrary('class C { external C operator+(C other); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external C +(C other) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external C +(C other) {}
+}
+''');
+ }
}
test_operator_greater_equal() {
- checkLibrary('class C { bool operator>=(C other) => false; }');
+ var library =
+ checkLibrary('class C { bool operator>=(C other) => false; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool >=(C other) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool >=(C other) {}
+}
+''');
+ }
}
test_operator_index() {
- checkLibrary('class C { bool operator[](int i) => null; }');
+ var library = checkLibrary('class C { bool operator[](int i) => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool [](int i) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool [](int i) {}
+}
+''');
+ }
}
test_operator_index_set() {
- checkLibrary('class C { void operator[]=(int i, bool v) {} }');
+ var library =
+ checkLibrary('class C { void operator[]=(int i, bool v) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void []=(int i, bool v) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void []=(int i, bool v) {}
+}
+''');
+ }
}
test_operator_less_equal() {
- checkLibrary('class C { bool operator<=(C other) => false; }');
+ var library =
+ checkLibrary('class C { bool operator<=(C other) => false; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool <=(C other) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool <=(C other) {}
+}
+''');
+ }
}
void test_parameter_checked() {
// Note: due to dartbug.com/27393, the keyword "checked" is identified by
// its presence in a library called "meta". If that bug is fixed, this test
// my need to be changed.
- checkLibrary(r'''
+ var library = checkLibrary(r'''
library meta;
const checked = null;
class A<T> {
void f(@checked T t) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library meta;
+class A<T> {
+ void f(@checked covariant T t) {}
+}
+const dynamic checked = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library meta;
+class A<T> {
+ void f(@checked covariant T t) {}
+}
+const dynamic checked = null;
+''');
+ }
}
void test_parameter_checked_inherited() {
// Note: due to dartbug.com/27393, the keyword "checked" is identified by
// its presence in a library called "meta". If that bug is fixed, this test
// my need to be changed.
- checkLibrary(r'''
+ var library = checkLibrary(r'''
library meta;
const checked = null;
class A<T> {
@@ -4587,15 +11730,59 @@
void f(T t) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library meta;
+class A<T> {
+ void f(@checked covariant T t) {}
+}
+class B<T> extends A<T> {
+ void f(covariant T t) {}
+}
+const dynamic checked = null;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library meta;
+class A<T> {
+ void f(@checked covariant T t) {}
+}
+class B<T> extends A<T> {
+ void f(T t) {}
+}
+const dynamic checked = null;
+''');
+ }
}
test_parameter_covariant() {
prepareAnalysisContext(createOptions());
- checkLibrary('class C { void m(covariant C c) {} }');
+ var library = checkLibrary('class C { void m(covariant C c) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void m(covariant C c) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void m(covariant C c) {}
+}
+''');
+ }
}
void test_parameter_covariant_inherited() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class A<T> {
void f(covariant T t) {}
}
@@ -4603,130 +11790,480 @@
void f(T t) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A<T> {
+ void f(covariant T t) {}
+}
+class B<T> extends A<T> {
+ void f(covariant T t) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A<T> {
+ void f(covariant T t) {}
+}
+class B<T> extends A<T> {
+ void f(T t) {}
+}
+''');
+ }
}
test_parameter_parameters() {
- checkLibrary('class C { f(g(x, y)) {} }');
+ var library = checkLibrary('class C { f(g(x, y)) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic f((dynamic, dynamic) → dynamic g) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic f((dynamic, dynamic) → dynamic g) {}
+}
+''');
+ }
}
test_parameter_parameters_in_generic_class() {
- checkLibrary('class C<A, B> { f(A g(B x)) {} }');
+ var library = checkLibrary('class C<A, B> { f(A g(B x)) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<A, B> {
+ dynamic f((B) → A g) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<A, B> {
+ dynamic f((B) → A g) {}
+}
+''');
+ }
}
test_parameter_return_type() {
- checkLibrary('class C { f(int g()) {} }');
+ var library = checkLibrary('class C { f(int g()) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic f(() → int g) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic f(() → int g) {}
+}
+''');
+ }
}
test_parameter_return_type_void() {
- checkLibrary('class C { f(void g()) {} }');
+ var library = checkLibrary('class C { f(void g()) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic f(() → void g) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic f(() → void g) {}
+}
+''');
+ }
}
test_parameterTypeNotInferred_constructor() {
// Strong mode doesn't do type inference on constructor parameters, so it's
// ok that we don't store inferred type info for them in summaries.
- checkLibrary('''
+ var library = checkLibrary('''
class C {
C.positional([x = 1]);
C.named({x: 1});
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.positional([dynamic x = 1]);
+ C.named({dynamic x: 1});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.positional([dynamic x = 1]);
+ C.named({dynamic x: 1});
+}
+''');
+ }
}
test_parameterTypeNotInferred_initializingFormal() {
// Strong mode doesn't do type inference on initializing formals, so it's
// ok that we don't store inferred type info for them in summaries.
- checkLibrary('''
+ var library = checkLibrary('''
class C {
var x;
C.positional([this.x = 1]);
C.named({this.x: 1});
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C.positional([dynamic this.x]);
+ C.named({dynamic this.x});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ dynamic x;
+ C.positional([dynamic this.x]);
+ C.named({dynamic this.x});
+}
+''');
+ }
}
test_parameterTypeNotInferred_staticMethod() {
// Strong mode doesn't do type inference on parameters of static methods,
// so it's ok that we don't store inferred type info for them in summaries.
- checkLibrary('''
+ var library = checkLibrary('''
class C {
static void positional([x = 1]) {}
static void named({x: 1}) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static void positional([dynamic x = 1]) {}
+ static void named({dynamic x: 1}) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static void positional([dynamic x = 1]) {}
+ static void named({dynamic x: 1}) {}
+}
+''');
+ }
}
test_parameterTypeNotInferred_topLevelFunction() {
// Strong mode doesn't do type inference on parameters of top level
// functions, so it's ok that we don't store inferred type info for them in
// summaries.
- checkLibrary('''
+ var library = checkLibrary('''
void positional([x = 1]) {}
void named({x: 1}) {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void positional([dynamic x = 1]) {}
+void named({dynamic x: 1}) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void positional([dynamic x = 1]) {}
+void named({dynamic x: 1}) {}
+''');
+ }
}
test_parts() {
addSource('/a.dart', 'part of my.lib;');
addSource('/b.dart', 'part of my.lib;');
- checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ var library = checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+--------------------
+unit: b.dart
+
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+--------------------
+unit: b.dart
+
+''');
+ }
}
test_parts_invalidUri() {
allowMissingFiles = true;
addSource('/foo/bar.dart', 'part of my.lib;');
- checkLibrary('library my.lib; part "foo/";');
+ var library = checkLibrary('library my.lib; part "foo/";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+''');
+ }
}
test_parts_invalidUri_nullStringValue() {
allowMissingFiles = true;
addSource('/foo/bar.dart', 'part of my.lib;');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
library my.lib;
part "${foo}/bar.dart";
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+''');
+ }
}
test_propagated_type_refers_to_closure() {
- checkLibrary('''
+ var library = checkLibrary('''
void f() {
var x = () => 0;
var y = x;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ }
}
test_setter_covariant() {
- checkLibrary('class C { void set x(covariant int value); }');
+ var library = checkLibrary('class C { void set x(covariant int value); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(covariant int value);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(covariant int value);
+}
+''');
+ }
}
test_setter_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
void set x(value) {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+void set x(dynamic value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+void set x(dynamic value) {}
+''');
+ }
}
test_setter_external() {
- checkLibrary('external void set x(int value);');
+ var library = checkLibrary('external void set x(int value);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+external void set x(int value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+external void set x(int value) {}
+''');
+ }
}
test_setter_inferred_type_nonStatic_implicit_param() {
- checkLibrary('class C extends D { void set f(value) {} }'
+ var library = checkLibrary('class C extends D { void set f(value) {} }'
' abstract class D { void set f(int value); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void set f(int value) {}
+}
+abstract class D {
+ void set f(int value);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void set f(dynamic value) {}
+}
+abstract class D {
+ void set f(int value);
+}
+''');
+ }
}
test_setter_inferred_type_static_implicit_return() {
- checkLibrary('class C { static set f(int value) {} }');
+ var library = checkLibrary('class C { static set f(int value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static void set f(int value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static dynamic set f(int value) {}
+}
+''');
+ }
}
test_setter_inferred_type_top_level_implicit_return() {
- checkLibrary('set f(int value) {}');
+ var library = checkLibrary('set f(int value) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void set f(int value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic set f(int value) {}
+''');
+ }
}
test_setters() {
- checkLibrary('void set x(int value) {} set y(value) {}');
+ var library = checkLibrary('void set x(int value) {} set y(value) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void set x(int value) {}
+void set y(dynamic value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void set x(int value) {}
+dynamic set y(dynamic value) {}
+''');
+ }
}
test_syntheticFunctionType_genericClosure() {
@@ -4739,10 +12276,21 @@
// and remove this hack. See dartbug.com/25819
return;
}
- checkLibrary('''
+ var library = checkLibrary('''
final v = f() ? /*<T>*/(T t) => 0 : /*<T>*/(T t) => 1;
bool f() => true;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_syntheticFunctionType_genericClosure_inGenericFunction() {
@@ -4755,70 +12303,217 @@
// and remove this hack. See dartbug.com/25819
return;
}
- checkLibrary('''
+ var library = checkLibrary('''
void f<T, U>(bool b) {
final v = b ? /*<V>*/(T t, U u, V v) => 0 : /*<V>*/(T t, U u, V v) => 1;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>(bool b) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_syntheticFunctionType_inGenericClass() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
var v = f() ? (T t, U u) => 0 : (T t, U u) => 1;
}
bool f() => false;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ synthetic C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ dynamic v;
+}
+bool f() {}
+''');
+ }
}
test_syntheticFunctionType_inGenericFunction() {
- checkLibrary('''
+ var library = checkLibrary('''
void f<T, U>(bool b) {
var v = b ? (T t, U u) => 0 : (T t, U u) => 1;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>(bool b) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>(bool b) {}
+''');
+ }
}
test_syntheticFunctionType_noArguments() {
- checkLibrary('''
+ var library = checkLibrary('''
final v = f() ? () => 0 : () => 1;
bool f() => true;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final dynamic v;
+bool f() {}
+''');
+ }
}
test_syntheticFunctionType_withArguments() {
- checkLibrary('''
+ var library = checkLibrary('''
final v = f() ? (int x, String y) => 0 : (int x, String y) => 1;
bool f() => true;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final dynamic v;
+bool f() {}
+''');
+ }
}
test_type_arguments_explicit_dynamic_dynamic() {
- checkLibrary('Map<dynamic, dynamic> m;');
+ var library = checkLibrary('Map<dynamic, dynamic> m;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+Map<dynamic, dynamic> m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+Map<dynamic, dynamic> m;
+''');
+ }
}
test_type_arguments_explicit_dynamic_int() {
- checkLibrary('Map<dynamic, int> m;');
+ var library = checkLibrary('Map<dynamic, int> m;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+Map<dynamic, int> m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+Map<dynamic, int> m;
+''');
+ }
}
test_type_arguments_explicit_String_dynamic() {
- checkLibrary('Map<String, dynamic> m;');
+ var library = checkLibrary('Map<String, dynamic> m;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+Map<String, dynamic> m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+Map<String, dynamic> m;
+''');
+ }
}
test_type_arguments_explicit_String_int() {
- checkLibrary('Map<String, int> m;');
+ var library = checkLibrary('Map<String, int> m;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+Map<String, int> m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+Map<String, int> m;
+''');
+ }
}
test_type_arguments_implicit() {
- checkLibrary('Map m;');
+ var library = checkLibrary('Map m;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+Map<dynamic, dynamic> m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+Map<dynamic, dynamic> m;
+''');
+ }
}
test_type_dynamic() {
- checkLibrary('dynamic d;');
+ var library = checkLibrary('dynamic d;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic d;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic d;
+''');
+ }
}
test_type_invalid_topLevelVariableElement_asType() {
- checkLibrary(
+ var library = checkLibrary(
'''
class C<T extends V> {}
typedef V F(V p);
@@ -4827,218 +12522,1025 @@
int V = 0;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(dynamic p);
+class C<T extends dynamic> {
+}
+dynamic V2;
+int V;
+dynamic f(dynamic p) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(dynamic p);
+class C<T extends dynamic> {
+}
+dynamic V2;
+int V;
+dynamic f(dynamic p) {}
+''');
+ }
}
test_type_invalid_topLevelVariableElement_asTypeArgument() {
- checkLibrary(
+ var library = checkLibrary(
'''
var V;
static List<V> V2;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic V;
+List<dynamic> V2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic V;
+List<dynamic> V2;
+''');
+ }
}
test_type_invalid_typeParameter_asPrefix() {
- checkLibrary(
+ var library = checkLibrary(
'''
class C<T> {
m(T.K p) {}
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ dynamic m(dynamic p) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ dynamic m(dynamic p) {}
+}
+''');
+ }
}
test_type_reference_lib_to_lib() {
- checkLibrary('class C {} enum E { v } typedef F(); C c; E e; F f;');
+ var library =
+ checkLibrary('class C {} enum E { v } typedef F(); C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F();
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+class C {
+}
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F();
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+class C {
+}
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_lib_to_part() {
addSource('/a.dart', 'part of l; class C {} enum E { v } typedef F();');
- checkLibrary('library l; part "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('library l; part "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+C c;
+E e;
+F f;
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+C c;
+E e;
+F f;
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+class C {
+}
+''');
+ }
}
test_type_reference_part_to_lib() {
addSource('/a.dart', 'part of l; C c; E e; F f;');
- checkLibrary(
+ var library = checkLibrary(
'library l; part "a.dart"; class C {} enum E { v } typedef F();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+typedef dynamic F();
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+class C {
+}
+--------------------
+unit: a.dart
+
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+typedef dynamic F();
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+class C {
+}
+--------------------
+unit: a.dart
+
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_part_to_other_part() {
addSource('/a.dart', 'part of l; class C {} enum E { v } typedef F();');
addSource('/b.dart', 'part of l; C c; E e; F f;');
- checkLibrary('library l; part "a.dart"; part "b.dart";');
+ var library = checkLibrary('library l; part "a.dart"; part "b.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+class C {
+}
+--------------------
+unit: b.dart
+
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+class C {
+}
+--------------------
+unit: b.dart
+
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_part_to_part() {
addSource('/a.dart',
'part of l; class C {} enum E { v } typedef F(); C c; E e; F f;');
- checkLibrary('library l; part "a.dart";');
+ var library = checkLibrary('library l; part "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+class C {
+}
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+class C {
+}
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_class() {
- checkLibrary('class C {} C c;');
+ var library = checkLibrary('class C {} C c;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+C c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+C c;
+''');
+ }
}
test_type_reference_to_class_with_type_arguments() {
- checkLibrary('class C<T, U> {} C<int, String> c;');
+ var library = checkLibrary('class C<T, U> {} C<int, String> c;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+C<int, String> c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+C<int, String> c;
+''');
+ }
}
test_type_reference_to_class_with_type_arguments_implicit() {
- checkLibrary('class C<T, U> {} C c;');
+ var library = checkLibrary('class C<T, U> {} C c;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+C<dynamic, dynamic> c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+C<dynamic, dynamic> c;
+''');
+ }
}
test_type_reference_to_enum() {
- checkLibrary('enum E { v } E e;');
+ var library = checkLibrary('enum E { v } E e;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+E e;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E {
+ final int index;
+ static const List<E> values;
+ static const E v;
+}
+E e;
+''');
+ }
}
test_type_reference_to_import() {
addLibrarySource('/a.dart', 'class C {} enum E { v }; typedef F();');
- checkLibrary('import "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_export() {
addLibrarySource('/a.dart', 'export "b.dart";');
addLibrarySource('/b.dart', 'class C {} enum E { v } typedef F();');
- checkLibrary('import "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_export_export() {
addLibrarySource('/a.dart', 'export "b.dart";');
addLibrarySource('/b.dart', 'export "c.dart";');
addLibrarySource('/c.dart', 'class C {} enum E { v } typedef F();');
- checkLibrary('import "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_export_export_in_subdirs() {
addLibrarySource('/a/a.dart', 'export "b/b.dart";');
addLibrarySource('/a/b/b.dart', 'export "../c/c.dart";');
addLibrarySource('/a/c/c.dart', 'class C {} enum E { v } typedef F();');
- checkLibrary('import "a/a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a/a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_export_in_subdirs() {
addLibrarySource('/a/a.dart', 'export "b/b.dart";');
addLibrarySource('/a/b/b.dart', 'class C {} enum E { v } typedef F();');
- checkLibrary('import "a/a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a/a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_part() {
addLibrarySource('/a.dart', 'library l; part "b.dart";');
addSource('/b.dart', 'part of l; class C {} enum E { v } typedef F();');
- checkLibrary('import "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_part2() {
addLibrarySource('/a.dart', 'library l; part "p1.dart"; part "p2.dart";');
addSource('/p1.dart', 'part of l; class C1 {}');
addSource('/p2.dart', 'part of l; class C2 {}');
- checkLibrary('import "a.dart"; C1 c1; C2 c2;');
+ var library = checkLibrary('import "a.dart"; C1 c1; C2 c2;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C1 c1;
+C2 c2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C1 c1;
+C2 c2;
+''');
+ }
}
test_type_reference_to_import_part_in_subdir() {
addLibrarySource('/a/b.dart', 'library l; part "c.dart";');
addSource('/a/c.dart', 'part of l; class C {} enum E { v } typedef F();');
- checkLibrary('import "a/b.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a/b.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a/b.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a/b.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_relative() {
addLibrarySource('/a.dart', 'class C {} enum E { v } typedef F();');
- checkLibrary('import "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_typedef() {
- checkLibrary('typedef F(); F f;');
+ var library = checkLibrary('typedef F(); F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F();
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F();
+F f;
+''');
+ }
}
test_type_reference_to_typedef_with_type_arguments() {
- checkLibrary('typedef U F<T, U>(T t); F<int, String> f;');
+ var library = checkLibrary('typedef U F<T, U>(T t); F<int, String> f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+ }
}
test_type_reference_to_typedef_with_type_arguments_implicit() {
- checkLibrary('typedef U F<T, U>(T t); F f;');
+ var library = checkLibrary('typedef U F<T, U>(T t); F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+ }
}
test_type_unresolved() {
- checkLibrary('C c;', allowErrors: true);
+ var library = checkLibrary('C c;', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic c;
+''');
+ }
}
test_type_unresolved_prefixed() {
- checkLibrary('import "dart:core" as core; core.C c;', allowErrors: true);
+ var library = checkLibrary('import "dart:core" as core; core.C c;',
+ allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:core' as core;
+dynamic c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:core' as core;
+dynamic c;
+''');
+ }
}
test_typedef_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
typedef F();''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+typedef dynamic F();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+typedef dynamic F();
+''');
+ }
}
test_typedef_parameter_parameters() {
- checkLibrary('typedef F(g(x, y));');
+ var library = checkLibrary('typedef F(g(x, y));');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F((dynamic, dynamic) → dynamic g);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F((dynamic, dynamic) → dynamic g);
+''');
+ }
}
test_typedef_parameter_parameters_in_generic_class() {
- checkLibrary('typedef F<A, B>(A g(B x));');
+ var library = checkLibrary('typedef F<A, B>(A g(B x));');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F<A, B>((B) → A g);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F<A, B>((B) → A g);
+''');
+ }
}
test_typedef_parameter_return_type() {
- checkLibrary('typedef F(int g());');
+ var library = checkLibrary('typedef F(int g());');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(() → int g);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(() → int g);
+''');
+ }
}
test_typedef_parameter_type() {
- checkLibrary('typedef F(int i);');
+ var library = checkLibrary('typedef F(int i);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(int i);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(int i);
+''');
+ }
}
test_typedef_parameter_type_generic() {
- checkLibrary('typedef F<T>(T t);');
+ var library = checkLibrary('typedef F<T>(T t);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F<T>(T t);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F<T>(T t);
+''');
+ }
}
test_typedef_parameters() {
- checkLibrary('typedef F(x, y);');
+ var library = checkLibrary('typedef F(x, y);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(dynamic x, dynamic y);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F(dynamic x, dynamic y);
+''');
+ }
}
test_typedef_return_type() {
- checkLibrary('typedef int F();');
+ var library = checkLibrary('typedef int F();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef int F();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef int F();
+''');
+ }
}
test_typedef_return_type_generic() {
- checkLibrary('typedef T F<T>();');
+ var library = checkLibrary('typedef T F<T>();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef T F<T>();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef T F<T>();
+''');
+ }
}
test_typedef_return_type_implicit() {
- checkLibrary('typedef F();');
+ var library = checkLibrary('typedef F();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F();
+''');
+ }
}
test_typedef_return_type_void() {
- checkLibrary('typedef void F();');
+ var library = checkLibrary('typedef void F();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef void F();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef void F();
+''');
+ }
}
test_typedef_type_parameters() {
- checkLibrary('typedef U F<T, U>(T t);');
+ var library = checkLibrary('typedef U F<T, U>(T t);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+''');
+ }
}
test_typedef_type_parameters_bound() {
- checkLibrary('typedef U F<T extends Object, U extends D>(T t); class D {}');
+ var library = checkLibrary(
+ 'typedef U F<T extends Object, U extends D>(T t); class D {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends Object, U extends D>(T t);
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends Object, U extends D>(T t);
+class D {
+}
+''');
+ }
}
test_typedef_type_parameters_f_bound_complex() {
- checkLibrary('typedef U F<T extends List<U>, U>(T t);');
+ var library = checkLibrary('typedef U F<T extends List<U>, U>(T t);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends List<U>, U>(T t);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends List<U>, U>(T t);
+''');
+ }
}
test_typedef_type_parameters_f_bound_simple() {
- checkLibrary('typedef U F<T extends U, U>(T t);');
+ var library = checkLibrary('typedef U F<T extends U, U>(T t);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends U, U>(T t);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends U, U>(T t);
+''');
+ }
}
test_typedefs() {
- checkLibrary('f() {} g() {}');
+ var library = checkLibrary('f() {} g() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+dynamic g() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic f() {}
+dynamic g() {}
+''');
+ }
}
@failingTest
test_unresolved_annotation_instanceCreation_argument_super() {
// TODO(scheglov) fix https://github.com/dart-lang/sdk/issues/28553
- checkLibrary(
+ var library = checkLibrary(
'''
class A {
const A(_);
@@ -5048,10 +13550,35 @@
class C {}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A(_);
+}
+
+class C {
+ synthetic C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A(_);
+}
+
+class C {
+ synthetic C();
+}
+''');
+ }
}
test_unresolved_annotation_instanceCreation_argument_this() {
- checkLibrary(
+ var library = checkLibrary(
'''
class A {
const A(_);
@@ -5061,59 +13588,294 @@
class C {}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A(dynamic _);
+}
+@A(this)
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ const A(dynamic _);
+}
+@A(this)
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_namedConstructorCall_noClass() {
- checkLibrary('@foo.bar() class C {}', allowErrors: true);
+ var library = checkLibrary('@foo.bar() class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@foo.bar()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@foo.bar()
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_namedConstructorCall_noConstructor() {
- checkLibrary('@String.foo() class C {}', allowErrors: true);
+ var library = checkLibrary('@String.foo() class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@String.foo()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@String.foo()
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedIdentifier_badPrefix() {
- checkLibrary('@foo.bar class C {}', allowErrors: true);
+ var library = checkLibrary('@foo.bar class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@foo.bar
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@foo.bar
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedIdentifier_noDeclaration() {
- checkLibrary('import "dart:async" as foo; @foo.bar class C {}',
+ var library = checkLibrary(
+ 'import "dart:async" as foo; @foo.bar class C {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+@foo.bar
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+@foo.bar
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedNamedConstructorCall_badPrefix() {
- checkLibrary('@foo.bar.baz() class C {}', allowErrors: true);
+ var library = checkLibrary('@foo.bar.baz() class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@foo.bar.baz()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@foo.bar.baz()
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedNamedConstructorCall_noClass() {
- checkLibrary('import "dart:async" as foo; @foo.bar.baz() class C {}',
+ var library = checkLibrary(
+ 'import "dart:async" as foo; @foo.bar.baz() class C {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+@foo.bar.baz()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+@foo.bar.baz()
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedNamedConstructorCall_noConstructor() {
- checkLibrary('import "dart:async" as foo; @foo.Future.bar() class C {}',
+ var library = checkLibrary(
+ 'import "dart:async" as foo; @foo.Future.bar() class C {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+@foo.Future.bar()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+@foo.Future.bar()
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedUnnamedConstructorCall_badPrefix() {
- checkLibrary('@foo.bar() class C {}', allowErrors: true);
+ var library = checkLibrary('@foo.bar() class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@foo.bar()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@foo.bar()
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedUnnamedConstructorCall_noClass() {
- checkLibrary('import "dart:async" as foo; @foo.bar() class C {}',
+ var library = checkLibrary(
+ 'import "dart:async" as foo; @foo.bar() class C {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+@foo.bar()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+@foo.bar()
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_simpleIdentifier() {
- checkLibrary('@foo class C {}', allowErrors: true);
+ var library = checkLibrary('@foo class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@foo
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@foo
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_unnamedConstructorCall_noClass() {
- checkLibrary('@foo() class C {}', allowErrors: true);
+ var library = checkLibrary('@foo() class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+@foo()
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+@foo()
+class C {
+}
+''');
+ }
}
test_unresolved_export() {
allowMissingFiles = true;
- checkLibrary("export 'foo.dart';", allowErrors: true);
+ var library = checkLibrary("export 'foo.dart';", allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'foo.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'foo.dart';
+''');
+ }
}
test_unresolved_import() {
@@ -5124,101 +13886,452 @@
expect(importedLibrary.loadLibraryFunction, isNotNull);
expect(importedLibrary.publicNamespace, isNotNull);
expect(importedLibrary.exportNamespace, isNotNull);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+''');
+ }
}
test_unresolved_part() {
allowMissingFiles = true;
- checkLibrary("part 'foo.dart';", allowErrors: true);
+ var library = checkLibrary("part 'foo.dart';", allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+part 'foo.dart';
+--------------------
+unit: foo.dart
+
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+part 'foo.dart';
+--------------------
+unit: foo.dart
+
+''');
+ }
}
test_unused_type_parameter() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T> {
void f() {}
}
C<int> c;
var v = c.f;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ void f() {}
+}
+C<int> c;
+() → void v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ void f() {}
+}
+C<int> c;
+dynamic v;
+''');
+ }
}
test_variable_const() {
- checkLibrary('const int i = 0;');
+ var library = checkLibrary('const int i = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int i = 0;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const int i = 0;
+''');
+ }
}
test_variable_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
var x;''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+dynamic x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+/**
+ * Docs
+ */
+dynamic x;
+''');
+ }
}
test_variable_final() {
- checkLibrary('final int x = 0;');
+ var library = checkLibrary('final int x = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+final int x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final int x;
+''');
+ }
}
test_variable_final_top_level_untyped() {
- checkLibrary('final v = 0;');
+ var library = checkLibrary('final v = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+final int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final dynamic v;
+''');
+ }
}
test_variable_getterInLib_setterInPart() {
addSource('/a.dart', 'part of my.lib; void set x(int _) {}');
- checkLibrary('library my.lib; part "a.dart"; int get x => 42;');
+ var library =
+ checkLibrary('library my.lib; part "a.dart"; int get x => 42;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+int get x {}
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+int get x {}
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+''');
+ }
}
test_variable_getterInPart_setterInLib() {
addSource('/a.dart', 'part of my.lib; int get x => 42;');
- checkLibrary('library my.lib; part "a.dart"; void set x(int _) {}');
+ var library =
+ checkLibrary('library my.lib; part "a.dart"; void set x(int _) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+void set x(int _) {}
+--------------------
+unit: a.dart
+
+int get x {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+void set x(int _) {}
+--------------------
+unit: a.dart
+
+int get x {}
+''');
+ }
}
test_variable_getterInPart_setterInPart() {
addSource('/a.dart', 'part of my.lib; int get x => 42;');
addSource('/b.dart', 'part of my.lib; void set x(int _) {}');
- checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ var library = checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+int get x {}
+--------------------
+unit: b.dart
+
+void set x(int _) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+int get x {}
+--------------------
+unit: b.dart
+
+void set x(int _) {}
+''');
+ }
}
test_variable_implicit_type() {
- checkLibrary('var x;');
+ var library = checkLibrary('var x;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic x;
+''');
+ }
}
test_variable_inferred_type_implicit_initialized() {
- checkLibrary('var v = 0;');
+ var library = checkLibrary('var v = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic v;
+''');
+ }
}
test_variable_propagatedType_const_noDep() {
- checkLibrary('const i = 0;');
+ var library = checkLibrary('const i = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int i = 0;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const dynamic i = 0;
+''');
+ }
}
test_variable_propagatedType_final_dep_inLib() {
addLibrarySource('/a.dart', 'final a = 1;');
- checkLibrary('import "a.dart"; final b = a / 2;');
+ var library = checkLibrary('import "a.dart"; final b = a / 2;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+final num b;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+final dynamic b;
+''');
+ }
}
test_variable_propagatedType_final_dep_inPart() {
addSource('/a.dart', 'part of lib; final a = 1;');
- checkLibrary('library lib; part "a.dart"; final b = a / 2;');
+ var library = checkLibrary('library lib; part "a.dart"; final b = a / 2;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+final num b;
+--------------------
+unit: a.dart
+
+final int a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+final dynamic b;
+--------------------
+unit: a.dart
+
+final dynamic a;
+''');
+ }
}
test_variable_propagatedType_final_noDep() {
- checkLibrary('final i = 0;');
+ var library = checkLibrary('final i = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+final int i;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final dynamic i;
+''');
+ }
}
test_variable_propagatedType_implicit_dep() {
// The propagated type is defined in a library that is not imported.
addLibrarySource('/a.dart', 'class C {}');
addLibrarySource('/b.dart', 'import "a.dart"; C f() => null;');
- checkLibrary('import "b.dart"; final x = f();');
+ var library = checkLibrary('import "b.dart"; final x = f();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'b.dart';
+final C x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'b.dart';
+final dynamic x;
+''');
+ }
}
test_variable_setterInPart_getterInPart() {
addSource('/a.dart', 'part of my.lib; void set x(int _) {}');
addSource('/b.dart', 'part of my.lib; int get x => 42;');
- checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ var library = checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+--------------------
+unit: b.dart
+
+int get x {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+--------------------
+unit: b.dart
+
+int get x {}
+''');
+ }
}
test_variables() {
- checkLibrary('int i; int j;');
+ var library = checkLibrary('int i; int j;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+int i;
+int j;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+int i;
+int j;
+''');
+ }
}
/**
diff --git a/pkg/analyzer_cli/analyzer_cli.iml b/pkg/analyzer_cli/analyzer_cli.iml
index 4a27243..8eaae91 100644
--- a/pkg/analyzer_cli/analyzer_cli.iml
+++ b/pkg/analyzer_cli/analyzer_cli.iml
@@ -7,7 +7,18 @@
<excludeFolder url="file://$MODULE_DIR$/bin/packages" />
<excludeFolder url="file://$MODULE_DIR$/build" />
<excludeFolder url="file://$MODULE_DIR$/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/bazel/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/bazel/proj/lib/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/bazel/proj/packages" />
<excludeFolder url="file://$MODULE_DIR$/test/data/embedder_client/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/errors_reported_once/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/lib/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/somepkgs/flutter/lib/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/somepkgs/flutter/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/somepkgs/meta/lib/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/somepkgs/meta/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/somepkgs/packages" />
<excludeFolder url="file://$MODULE_DIR$/test/data/library_and_parts/packages" />
<excludeFolder url="file://$MODULE_DIR$/test/data/linter_project/packages" />
<excludeFolder url="file://$MODULE_DIR$/test/data/no_lints_project/packages" />
diff --git a/pkg/front_end/front_end.iml b/pkg/front_end/front_end.iml
index 8b2c80f..7f7c017 100644
--- a/pkg/front_end/front_end.iml
+++ b/pkg/front_end/front_end.iml
@@ -2,7 +2,20 @@
<module type="WEB_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
- <content url="file://$MODULE_DIR$" />
+ <content url="file://$MODULE_DIR$">
+ <excludeFolder url="file://$MODULE_DIR$/.pub" />
+ <excludeFolder url="file://$MODULE_DIR$/build" />
+ <excludeFolder url="file://$MODULE_DIR$/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/fasta/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/fasta/parser/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/fasta/rasta/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/fasta/scanner/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/src/base/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/test/src/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/tool/fasta/packages" />
+ <excludeFolder url="file://$MODULE_DIR$/tool/packages" />
+ </content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="Dart SDK" level="application" />
diff --git a/pkg/front_end/lib/src/fasta/builder/dynamic_type_builder.dart b/pkg/front_end/lib/src/fasta/builder/dynamic_type_builder.dart
index 5a74165..3933e7c 100644
--- a/pkg/front_end/lib/src/fasta/builder/dynamic_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/dynamic_type_builder.dart
@@ -13,7 +13,9 @@
DynamicTypeBuilder(this.type, LibraryBuilder compilationUnit, int charOffset)
: super(null, 0, "dynamic", compilationUnit, charOffset);
- R buildType(List<T> arguments) => type;
+ R buildType(LibraryBuilder library, List<T> arguments) => type;
- R buildTypesWithBuiltArguments(List<R> arguments) => type;
+ R buildTypesWithBuiltArguments(LibraryBuilder library, List<R> arguments) {
+ return type;
+ }
}
diff --git a/pkg/front_end/lib/src/fasta/builder/type_builder.dart b/pkg/front_end/lib/src/fasta/builder/type_builder.dart
index 4a91321..8f0065e 100644
--- a/pkg/front_end/lib/src/fasta/builder/type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/type_builder.dart
@@ -4,7 +4,8 @@
library fasta.type_builder;
-import 'builder.dart' show Builder, TypeDeclarationBuilder, TypeVariableBuilder;
+import 'builder.dart'
+ show Builder, LibraryBuilder, TypeDeclarationBuilder, TypeVariableBuilder;
import 'scope.dart' show Scope;
@@ -27,5 +28,5 @@
TypeBuilder subst(Map<TypeVariableBuilder, TypeBuilder> substitution) => this;
- build();
+ build(LibraryBuilder library);
}
diff --git a/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart b/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart
index e0cc771..0053c44 100644
--- a/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart
@@ -5,7 +5,7 @@
library fasta.type_declaration_builder;
import 'builder.dart'
- show Builder, MetadataBuilder, ModifierBuilder, TypeBuilder;
+ show Builder, LibraryBuilder, MetadataBuilder, ModifierBuilder, TypeBuilder;
import '../util/relativize.dart' show relativizeUri;
@@ -32,8 +32,10 @@
bool get isTypeDeclaration => true;
- R buildType(List<T> arguments);
+ bool get isTypeVariable => false;
+
+ R buildType(LibraryBuilder library, List<T> arguments);
/// [arguments] have already been built.
- R buildTypesWithBuiltArguments(List<R> arguments);
+ R buildTypesWithBuiltArguments(LibraryBuilder library, List<R> arguments);
}
diff --git a/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart b/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart
index ee94d2c..a7b5df7 100644
--- a/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart
@@ -14,6 +14,8 @@
String name, this.bound, LibraryBuilder compilationUnit, int charOffset)
: super(null, null, name, compilationUnit, charOffset);
+ bool get isTypeVariable => true;
+
String get debugName => "TypeVariableBuilder";
StringBuffer printOn(StringBuffer buffer) {
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 e906a19..532feca 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -175,7 +175,7 @@
} else if (node is BuilderAccessor) {
return node.buildSimpleRead();
} else if (node is TypeVariableBuilder) {
- TypeParameterType type = node.buildTypesWithBuiltArguments(null);
+ TypeParameterType type = node.buildTypesWithBuiltArguments(library, null);
if (!isInstanceContext && type.parameter.parent is Class) {
return buildCompileTimeError(
"Type variables can only be used in instance methods.");
@@ -183,9 +183,9 @@
return new TypeLiteral(type);
}
} else if (node is TypeDeclarationBuilder) {
- return new TypeLiteral(node.buildTypesWithBuiltArguments(null));
+ return new TypeLiteral(node.buildTypesWithBuiltArguments(library, null));
} else if (node is KernelTypeBuilder) {
- return new TypeLiteral(node.build());
+ return new TypeLiteral(node.build(library));
} else if (node is Expression) {
return node;
} else if (node is PrefixBuilder) {
@@ -949,8 +949,8 @@
Expression value = popForValue();
var accessor = pop();
if (accessor is TypeDeclarationBuilder) {
- push(wrapInvalid(
- new TypeLiteral(accessor.buildTypesWithBuiltArguments(null))));
+ push(wrapInvalid(new TypeLiteral(
+ accessor.buildTypesWithBuiltArguments(library, null))));
} else if (accessor is! BuilderAccessor) {
push(buildCompileTimeError("Can't assign to this.", token.charOffset));
} else {
@@ -1148,7 +1148,7 @@
if (identical(name, "dynamic")) return const DynamicType();
Builder builder = scope.lookup(name, charOffset, uri);
if (builder is TypeDeclarationBuilder) {
- return builder.buildTypesWithBuiltArguments(arguments);
+ return builder.buildTypesWithBuiltArguments(library, arguments);
}
if (builder == null) {
warning("Type not found: '$name'.", charOffset);
@@ -1202,11 +1202,11 @@
warning("'${name.name}' isn't a type.", beginToken.charOffset);
push(const DynamicType());
} else if (name is TypeVariableBuilder) {
- push(name.buildTypesWithBuiltArguments(arguments));
+ push(name.buildTypesWithBuiltArguments(library, arguments));
} else if (name is TypeDeclarationBuilder) {
- push(name.buildTypesWithBuiltArguments(arguments));
+ push(name.buildTypesWithBuiltArguments(library, arguments));
} else if (name is TypeBuilder) {
- push(name.build());
+ push(name.build(library));
} else {
push(toKernelType(name, arguments, beginToken.charOffset));
}
@@ -1293,7 +1293,7 @@
thisKeyword = null;
}
} else if (thisKeyword == null) {
- variable = builder.build();
+ variable = builder.build(library);
variable.initializer = name.initializer;
} else if (builder.isField && builder.parent == classBuilder) {
FieldBuilder field = builder;
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart
index a6a7025..185e1d5 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart
@@ -62,7 +62,8 @@
Class get target => cls;
/// [arguments] have already been built.
- InterfaceType buildTypesWithBuiltArguments(List<DartType> arguments) {
+ InterfaceType buildTypesWithBuiltArguments(
+ LibraryBuilder library, List<DartType> arguments) {
return arguments == null
? cls.rawType
: new InterfaceType(
@@ -72,27 +73,29 @@
computeDefaultTypeArguments(cls.typeParameters, arguments));
}
- InterfaceType buildType(List<KernelTypeBuilder> arguments) {
+ InterfaceType buildType(
+ LibraryBuilder library, List<KernelTypeBuilder> arguments) {
List<DartType> typeArguments;
if (arguments != null) {
typeArguments = <DartType>[];
for (KernelTypeBuilder builder in arguments) {
- DartType type = builder.build();
+ DartType type = builder.build(library);
if (type == null) {
internalError("Bad type: ${builder.runtimeType}");
}
typeArguments.add(type);
}
}
- return buildTypesWithBuiltArguments(typeArguments);
+ return buildTypesWithBuiltArguments(library, typeArguments);
}
- Supertype buildSupertype(List<KernelTypeBuilder> arguments) {
+ Supertype buildSupertype(
+ LibraryBuilder library, List<KernelTypeBuilder> arguments) {
List<DartType> typeArguments;
if (arguments != null) {
typeArguments = <DartType>[];
for (KernelTypeBuilder builder in arguments) {
- DartType type = builder.build();
+ DartType type = builder.build(library);
if (type == null) {
internalError("Bad type: ${builder.runtimeType}");
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart
index 1a36877..4261723 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart
@@ -174,7 +174,8 @@
KernelTypeBuilder get mixedInType => null;
- InterfaceType buildType(List<KernelTypeBuilder> arguments) {
+ InterfaceType buildType(
+ LibraryBuilder library, List<KernelTypeBuilder> arguments) {
return cls.rawType;
}
@@ -183,10 +184,10 @@
libraryBuilder.addCompileTimeError(
-1, "An enum declaration can't be empty.");
}
- toStringMap.keyType = intType.build();
- toStringMap.valueType = stringType.build();
+ toStringMap.keyType = intType.build(libraryBuilder);
+ toStringMap.valueType = stringType.build(libraryBuilder);
KernelFieldBuilder indexFieldBuilder = members["index"];
- Field indexField = indexFieldBuilder.build(libraryBuilder.library);
+ Field indexField = indexFieldBuilder.build(libraryBuilder);
KernelProcedureBuilder toStringBuilder = members["toString"];
toStringBuilder.body = new ReturnStatement(new MethodInvocation(
toStringMap,
@@ -197,14 +198,14 @@
List<Expression> values = <Expression>[];
for (String name in constants) {
KernelFieldBuilder builder = members[name];
- values.add(new StaticGet(builder.build(libraryBuilder.library)));
+ values.add(new StaticGet(builder.build(libraryBuilder)));
}
KernelFieldBuilder valuesBuilder = members["values"];
- valuesBuilder.build(libraryBuilder.library);
+ valuesBuilder.build(libraryBuilder);
valuesBuilder.initializer =
new ListLiteral(values, typeArgument: cls.rawType, isConst: true);
KernelConstructorBuilder constructorBuilder = members[""];
- Constructor constructor = constructorBuilder.build(libraryBuilder.library);
+ Constructor constructor = constructorBuilder.build(libraryBuilder);
constructor.initializers.insert(
0,
new FieldInitializer(indexField,
@@ -213,7 +214,7 @@
int index = 0;
for (String constant in constants) {
KernelFieldBuilder field = members[constant];
- field.build(libraryBuilder.library);
+ field.build(libraryBuilder);
Arguments arguments =
new Arguments(<Expression>[new IntLiteral(index++)]);
field.initializer =
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart
index 2f0cfd2..8cb5a8d 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart
@@ -4,10 +4,15 @@
library fasta.kernel_field_builder;
-import 'package:kernel/ast.dart' show Expression, Field, Library, Name;
+import 'package:kernel/ast.dart' show Expression, Field, Name;
import 'kernel_builder.dart'
- show Builder, FieldBuilder, KernelTypeBuilder, MetadataBuilder;
+ show
+ Builder,
+ FieldBuilder,
+ KernelTypeBuilder,
+ LibraryBuilder,
+ MetadataBuilder;
class KernelFieldBuilder extends FieldBuilder<Expression> {
final Field field;
@@ -24,10 +29,10 @@
field.initializer = value..parent = field;
}
- Field build(Library library) {
- field.name ??= new Name(name, library);
+ Field build(LibraryBuilder library) {
+ field.name ??= new Name(name, library.target);
if (type != null) {
- field.type = type.build();
+ field.type = type.build(library);
}
bool isInstanceMember = !isStatic && !isTopLevel;
return field
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_formal_parameter_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_formal_parameter_builder.dart
index aa671e9..09bd875 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_formal_parameter_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_formal_parameter_builder.dart
@@ -11,6 +11,7 @@
FormalParameterBuilder,
KernelLibraryBuilder,
KernelTypeBuilder,
+ LibraryBuilder,
MetadataBuilder;
class KernelFormalParameterBuilder
@@ -28,9 +29,9 @@
: super(metadata, modifiers, type, name, hasThis, compilationUnit,
charOffset);
- VariableDeclaration build() {
+ VariableDeclaration build(LibraryBuilder library) {
return declaration ??= new VariableDeclaration(name,
- type: type?.build() ?? const DynamicType(),
+ type: type?.build(library) ?? const DynamicType(),
isFinal: isFinal,
isConst: isConst);
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_function_type_alias_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_function_type_alias_builder.dart
index 63e2010..70e0205 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_function_type_alias_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_function_type_alias_builder.dart
@@ -46,7 +46,7 @@
: super(metadata, returnType, name, typeVariables, formals, parent,
charOffset);
- DartType buildThisType() {
+ DartType buildThisType(LibraryBuilder library) {
if (thisType != null) {
if (thisType == const InvalidType()) {
thisType = const DynamicType();
@@ -57,13 +57,14 @@
return thisType;
}
thisType = const InvalidType();
- DartType returnType = this.returnType?.build() ?? const DynamicType();
+ DartType returnType =
+ this.returnType?.build(library) ?? const DynamicType();
List<DartType> positionalParameters = <DartType>[];
List<NamedType> namedParameters;
int requiredParameterCount = 0;
if (formals != null) {
for (KernelFormalParameterBuilder formal in formals) {
- DartType type = formal.type?.build() ?? const DynamicType();
+ DartType type = formal.type?.build(library) ?? const DynamicType();
if (formal.isPositional) {
positionalParameters.add(type);
if (formal.isRequired) requiredParameterCount++;
@@ -90,8 +91,9 @@
}
/// [arguments] have already been built.
- DartType buildTypesWithBuiltArguments(List<DartType> arguments) {
- var thisType = buildThisType();
+ DartType buildTypesWithBuiltArguments(
+ LibraryBuilder library, List<DartType> arguments) {
+ var thisType = buildThisType(library);
if (thisType is DynamicType) return thisType;
FunctionType result = thisType;
if (result.typeParameters.isEmpty && arguments == null) return result;
@@ -103,8 +105,9 @@
return substitute(result.withoutTypeParameters, substitution);
}
- DartType buildType(List<KernelTypeBuilder> arguments) {
- var thisType = buildThisType();
+ DartType buildType(
+ LibraryBuilder library, List<KernelTypeBuilder> arguments) {
+ var thisType = buildThisType(library);
if (thisType is DynamicType) return thisType;
FunctionType result = thisType;
if (result.typeParameters.isEmpty && arguments == null) return result;
@@ -112,9 +115,9 @@
List<DartType> builtArguments = <DartType>[];
if (arguments != null) {
for (int i = 0; i < arguments.length; i++) {
- builtArguments.add(arguments[i].build());
+ builtArguments.add(arguments[i].build(library));
}
}
- return buildTypesWithBuiltArguments(builtArguments);
+ return buildTypesWithBuiltArguments(library, builtArguments);
}
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_invalid_type_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_invalid_type_builder.dart
index da0f433..b2c215b 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_invalid_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_invalid_type_builder.dart
@@ -8,21 +8,24 @@
import '../messages.dart' show warning;
-import 'kernel_builder.dart' show InvalidTypeBuilder, KernelTypeBuilder;
+import 'kernel_builder.dart'
+ show InvalidTypeBuilder, KernelTypeBuilder, LibraryBuilder;
class KernelInvalidTypeBuilder
extends InvalidTypeBuilder<KernelTypeBuilder, DartType> {
KernelInvalidTypeBuilder(String name, int charOffset, Uri fileUri)
: super(name, null, charOffset, fileUri);
- DartType buildType(List<KernelTypeBuilder> arguments) {
+ DartType buildType(
+ LibraryBuilder library, List<KernelTypeBuilder> arguments) {
// TODO(ahe): Implement error handling.
warning(fileUri, charOffset, "No type for: '$name'.");
return const DynamicType();
}
/// [Arguments] have already been built.
- DartType buildTypesWithBuiltArguments(List<DartType> arguments) {
+ DartType buildTypesWithBuiltArguments(
+ LibraryBuilder library, List<DartType> arguments) {
// TODO(ahe): Implement error handling.
warning(fileUri, charOffset, "No type for: '$name'.");
return const DynamicType();
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart
index fae44fc..c2d6b22 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart
@@ -68,6 +68,8 @@
: library = new Library(uri, fileUri: relativizeUri(fileUri)),
super(loader, fileUri);
+ Library get target => library;
+
Uri get uri => library.importUri;
KernelTypeBuilder addNamedType(
@@ -280,9 +282,9 @@
Class cls = builder.build(this);
library.addClass(cls);
} else if (builder is KernelFieldBuilder) {
- library.addMember(builder.build(library)..isStatic = true);
+ library.addMember(builder.build(this)..isStatic = true);
} else if (builder is KernelProcedureBuilder) {
- library.addMember(builder.build(library)..isStatic = true);
+ library.addMember(builder.build(this)..isStatic = true);
} else if (builder is FunctionTypeAliasBuilder) {
// Kernel discard typedefs and use their corresponding function types
// directly.
@@ -394,7 +396,7 @@
int finishTypeVariables(ClassBuilder object) {
int count = boundlessTypeVariables.length;
for (KernelTypeVariableBuilder builder in boundlessTypeVariables) {
- builder.finish(object);
+ builder.finish(this, object);
}
boundlessTypeVariables.clear();
return count;
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_mixin_application_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_mixin_application_builder.dart
index c79e55f..8b9d903 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_mixin_application_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_mixin_application_builder.dart
@@ -16,6 +16,7 @@
KernelNamedTypeBuilder,
KernelTypeBuilder,
KernelTypeVariableBuilder,
+ LibraryBuilder,
MixinApplicationBuilder,
TypeBuilder,
TypeVariableBuilder;
@@ -45,15 +46,17 @@
relativeFileUri = relativizeUri(fileUri),
super(supertype, mixins, charOffset, fileUri);
- InterfaceType build() => buildSupertype().asInterfaceType;
+ InterfaceType build(LibraryBuilder library) {
+ return buildSupertype(library)?.asInterfaceType;
+ }
- Supertype buildSupertype() {
+ Supertype buildSupertype(LibraryBuilder library) {
if (builtType != null) return builtType;
KernelTypeBuilder s = this.supertype;
for (KernelTypeBuilder builder in mixins) {
s = applyMixin(s, builder);
}
- builtType = s.buildSupertype();
+ builtType = s.buildSupertype(library);
return builtType;
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_named_type_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_named_type_builder.dart
index f4f88ac..7dd7fb3 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_named_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_named_type_builder.dart
@@ -14,6 +14,7 @@
KernelClassBuilder,
KernelInvalidTypeBuilder,
KernelTypeBuilder,
+ LibraryBuilder,
NamedTypeBuilder,
TypeBuilder,
TypeVariableBuilder;
@@ -37,27 +38,35 @@
return const DynamicType();
}
- Supertype handleMissingSuperType() {
+ Supertype handleMissingSupertype() {
warning(fileUri, charOffset, "No type for: '$name'.");
return null;
}
- DartType build() {
+ Supertype handleInvalidSupertype(LibraryBuilder library) {
+ String message = builder.isTypeVariable
+ ? "The type variable '$name' can't be used as supertype."
+ : "The type '$name' can't be used as supertype.";
+ library.addCompileTimeError(charOffset, message, fileUri);
+ return null;
+ }
+
+ DartType build(LibraryBuilder library) {
if (name == "void") return const VoidType();
if (name == "dynamic") return const DynamicType();
if (builder == null) return handleMissingType();
- return builder.buildType(arguments);
+ return builder.buildType(library, arguments);
}
- Supertype buildSupertype() {
+ Supertype buildSupertype(LibraryBuilder library) {
if (name == "void") return null;
if (name == "dynamic") return null;
- if (builder == null) return handleMissingSuperType();
+ if (builder == null) return handleMissingSupertype();
if (builder is KernelClassBuilder) {
KernelClassBuilder builder = this.builder;
- return builder.buildSupertype(arguments);
+ return builder.buildSupertype(library, arguments);
} else {
- return handleMissingSuperType();
+ return handleInvalidSupertype(library);
}
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart
index 08b6f47..cd8ee41 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart
@@ -16,7 +16,6 @@
Expression,
FunctionNode,
Initializer,
- Library,
LocalInitializer,
Member,
Name,
@@ -52,6 +51,7 @@
KernelLibraryBuilder,
KernelTypeBuilder,
KernelTypeVariableBuilder,
+ LibraryBuilder,
MetadataBuilder,
ProcedureBuilder,
TypeVariableBuilder,
@@ -93,7 +93,7 @@
bool get isNative => nativeMethodName != null;
- FunctionNode buildFunction() {
+ FunctionNode buildFunction(LibraryBuilder library) {
assert(function == null);
FunctionNode result = new FunctionNode(body, asyncMarker: asyncModifier);
if (typeVariables != null) {
@@ -104,7 +104,7 @@
}
if (formals != null) {
for (KernelFormalParameterBuilder formal in formals) {
- VariableDeclaration parameter = formal.build();
+ VariableDeclaration parameter = formal.build(library);
if (formal.isNamed) {
result.namedParameters.add(parameter);
} else {
@@ -117,7 +117,7 @@
}
}
if (returnType != null) {
- result.returnType = returnType.build();
+ result.returnType = returnType.build(library);
}
if (!isConstructor && !isInstanceMember && parent is ClassBuilder) {
List<TypeParameter> typeParameters = parent.target.typeParameters;
@@ -154,7 +154,7 @@
return function = result;
}
- Member build(Library library);
+ Member build(LibraryBuilder library);
void becomeNative(Loader loader) {
target.isExternal = true;
@@ -220,16 +220,16 @@
}
}
- Procedure build(Library library) {
+ Procedure build(LibraryBuilder library) {
// TODO(ahe): I think we may call this twice on parts. Investigate.
if (procedure.name == null) {
- procedure.function = buildFunction();
+ procedure.function = buildFunction(library);
procedure.function.parent = procedure;
procedure.isAbstract = isAbstract;
procedure.isStatic = isStatic;
procedure.isExternal = isExternal;
procedure.isConst = isConst;
- procedure.name = new Name(name, library);
+ procedure.name = new Name(name, library.target);
}
return procedure;
}
@@ -268,20 +268,20 @@
ProcedureKind get kind => null;
- Constructor build(Library library) {
+ Constructor build(LibraryBuilder library) {
if (constructor.name == null) {
- constructor.function = buildFunction();
+ constructor.function = buildFunction(library);
constructor.function.parent = constructor;
constructor.isConst = isConst;
constructor.isExternal = isExternal;
- constructor.name = new Name(name, library);
+ constructor.name = new Name(name, library.target);
}
return constructor;
}
- FunctionNode buildFunction() {
+ FunctionNode buildFunction(LibraryBuilder library) {
// TODO(ahe): Should complain if another type is explicitly set.
- return super.buildFunction()..returnType = const VoidType();
+ return super.buildFunction(library)..returnType = const VoidType();
}
Constructor get target => constructor;
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 2ed1a8c..93ef761 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
@@ -132,9 +132,6 @@
Builder builder = type.builder;
if (builder is ClassBuilder) {
set.add(builder);
- } else if (builder is! InvalidTypeBuilder &&
- builder is! DynamicTypeBuilder) {
- internalError("Unhandled: ${builder.runtimeType}");
}
}
@@ -247,7 +244,7 @@
loader.buildProgram();
loader.checkSemantics();
List<SourceClassBuilder> sourceClasses = collectAllSourceClasses();
- installDefaultSupertypes(sourceClasses);
+ installDefaultSupertypes();
installDefaultConstructors(sourceClasses);
loader.resolveConstructors();
loader.finishTypeVariables(objectClassBuilder);
@@ -353,17 +350,21 @@
return null;
}
- void installDefaultSupertypes(List<SourceClassBuilder> builders) {
+ void installDefaultSupertypes() {
Class objectClass = this.objectClass;
- for (SourceClassBuilder builder in builders) {
- Class cls = builder.target;
- if (cls != objectClass) {
- cls.supertype ??= objectClass.asRawSupertype;
- }
- if (builder.isMixinApplication) {
- cls.mixedInType = builder.mixedInType.buildSupertype();
- }
- }
+ loader.builders.forEach((Uri uri, LibraryBuilder library) {
+ library.members.forEach((String name, Builder builder) {
+ if (builder is SourceClassBuilder) {
+ Class cls = builder.target;
+ if (cls != objectClass) {
+ cls.supertype ??= objectClass.asRawSupertype;
+ }
+ if (builder.isMixinApplication) {
+ cls.mixedInType = builder.mixedInType.buildSupertype(library);
+ }
+ }
+ });
+ });
ticker.logMs("Installed Object as implicit superclass");
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_type_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_type_builder.dart
index a1c3b70..9bee8f9 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_type_builder.dart
@@ -6,12 +6,12 @@
import 'package:kernel/ast.dart' show DartType, Supertype;
-import 'kernel_builder.dart' show TypeBuilder;
+import 'kernel_builder.dart' show LibraryBuilder, TypeBuilder;
abstract class KernelTypeBuilder extends TypeBuilder {
KernelTypeBuilder(int charOffset, Uri fileUri) : super(charOffset, fileUri);
- DartType build();
+ DartType build(LibraryBuilder library);
- Supertype buildSupertype();
+ Supertype buildSupertype(LibraryBuilder library);
}
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_type_variable_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_type_variable_builder.dart
index 585bf1a..7475312 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_type_variable_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_type_variable_builder.dart
@@ -15,6 +15,7 @@
KernelLibraryBuilder,
KernelNamedTypeBuilder,
KernelTypeBuilder,
+ LibraryBuilder,
TypeVariableBuilder;
class KernelTypeVariableBuilder
@@ -27,7 +28,8 @@
: parameter = new TypeParameter(name, null),
super(name, bound, compilationUnit, charOffset);
- DartType buildType(List<KernelTypeBuilder> arguments) {
+ DartType buildType(
+ LibraryBuilder library, List<KernelTypeBuilder> arguments) {
if (arguments != null) {
return inputError(null, null,
"Can't use type arguments with type parameter $parameter");
@@ -36,12 +38,13 @@
}
}
- DartType buildTypesWithBuiltArguments(List<DartType> arguments) {
+ DartType buildTypesWithBuiltArguments(
+ LibraryBuilder library, List<DartType> arguments) {
if (arguments != null) {
return inputError(null, null,
"Can't use type arguments with type parameter $parameter");
} else {
- return buildType(null);
+ return buildType(library, null);
}
}
@@ -49,7 +52,7 @@
return new KernelNamedTypeBuilder(name, null, -1, null)..builder = this;
}
- void finish(KernelClassBuilder object) {
- parameter.bound = bound?.build() ?? object.buildType(null);
+ void finish(LibraryBuilder library, KernelClassBuilder object) {
+ parameter.bound = bound?.build(library) ?? object.buildType(library, null);
}
}
diff --git a/pkg/front_end/lib/src/fasta/outline.dart b/pkg/front_end/lib/src/fasta/outline.dart
index 0604a26..1b14e2a 100644
--- a/pkg/front_end/lib/src/fasta/outline.dart
+++ b/pkg/front_end/lib/src/fasta/outline.dart
@@ -92,7 +92,8 @@
}
Future<KernelTarget> buildOutline([Uri output]) async {
- TranslateUri uriTranslator = await TranslateUri.parse(c.options.sdk);
+ TranslateUri uriTranslator =
+ await TranslateUri.parse(c.options.sdk, c.options.packages);
ticker.logMs("Read packages file");
DillTarget dillTarget = new DillTarget(ticker, uriTranslator);
KernelTarget kernelTarget = createKernelTarget(dillTarget, uriTranslator);
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 3c2abf2..017534b 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
@@ -85,9 +85,9 @@
if (builder is KernelFieldBuilder) {
// TODO(ahe): It would be nice to have a common interface for the build
// method to avoid duplicating these two cases.
- cls.addMember(builder.build(library.library));
+ cls.addMember(builder.build(library));
} else if (builder is KernelFunctionBuilder) {
- cls.addMember(builder.build(library.library));
+ cls.addMember(builder.build(library));
} else {
internalError("Unhandled builder: ${builder.runtimeType}");
}
@@ -99,14 +99,14 @@
builder = builder.next;
} while (builder != null);
});
- cls.supertype = supertype?.buildSupertype();
- cls.mixedInType = mixedInType?.buildSupertype();
+ cls.supertype = supertype?.buildSupertype(library);
+ cls.mixedInType = mixedInType?.buildSupertype(library);
// TODO(ahe): If `cls.supertype` is null, and this isn't Object, report a
// compile-time error.
cls.isAbstract = isAbstract;
if (interfaces != null) {
for (KernelTypeBuilder interface in interfaces) {
- Supertype supertype = interface.buildSupertype();
+ Supertype supertype = interface.buildSupertype(library);
if (supertype != null) {
// TODO(ahe): Report an error if supertype is null.
cls.implementedTypes.add(supertype);
diff --git a/pkg/front_end/test/fasta/compile.status b/pkg/front_end/test/fasta/compile.status
index 79faa18..7772214 100644
--- a/pkg/front_end/test/fasta/compile.status
+++ b/pkg/front_end/test/fasta/compile.status
@@ -7,9 +7,10 @@
# pkg/fasta/lib/src/kernel/.
await: Fail
-invocations: Fail
function_type_recovery: Crash
+invocations: Fail
statements: Fail # Make async tranformer optional for golden file testing.
+type_variable_as_super: Fail
rasta/abstract_constructor: Fail
rasta/bad_constructor_redirection: Fail
diff --git a/pkg/front_end/test/fasta/kompile.status b/pkg/front_end/test/fasta/kompile.status
index f0dc306..3442779 100644
--- a/pkg/front_end/test/fasta/kompile.status
+++ b/pkg/front_end/test/fasta/kompile.status
@@ -27,6 +27,7 @@
statements: Crash
super_rasta_copy: Crash
top_level_accessors: Crash
+type_variable_as_super: Fail
typedef: Crash
rasta/abstract_constructor: Fail
diff --git a/runtime/bin/gen_snapshot.cc b/runtime/bin/gen_snapshot.cc
index 3a72a05..dfd09643 100644
--- a/runtime/bin/gen_snapshot.cc
+++ b/runtime/bin/gen_snapshot.cc
@@ -80,6 +80,7 @@
static const char* assembly_filename = NULL;
static const char* script_snapshot_filename = NULL;
static bool dependencies_only = false;
+static bool print_dependencies = false;
static const char* dependencies_filename = NULL;
@@ -331,6 +332,17 @@
return false;
}
+static bool ProcessPrintDependenciesOption(const char* option) {
+ const char* name = ProcessOption(option, "--print_dependencies");
+ if (name == NULL) {
+ name = ProcessOption(option, "--print-dependencies");
+ }
+ if (name != NULL) {
+ print_dependencies = true;
+ return true;
+ }
+ return false;
+}
static bool ProcessEmbedderEntryPointsManifestOption(const char* option) {
const char* name = ProcessOption(option, "--embedder_entry_points_manifest=");
@@ -406,6 +418,7 @@
ProcessScriptSnapshotOption(argv[i]) ||
ProcessDependenciesOption(argv[i]) ||
ProcessDependenciesOnlyOption(argv[i]) ||
+ ProcessPrintDependenciesOption(argv[i]) ||
ProcessEmbedderEntryPointsManifestOption(argv[i]) ||
ProcessURLmappingOption(argv[i]) || ProcessPackageRootOption(argv[i]) ||
ProcessPackagesOption(argv[i]) || ProcessEnvironmentOption(argv[i])) {
@@ -673,55 +686,72 @@
return;
}
- ASSERT(dependencies_filename != NULL);
- File* file = File::Open(dependencies_filename, File::kWriteTruncate);
- if (file == NULL) {
- Log::PrintErr("Error: Unable to open dependencies file: %s\n\n",
- dependencies_filename);
- exit(kErrorExitCode);
- }
+ ASSERT((dependencies_filename != NULL) || print_dependencies);
bool success = true;
+ File* file = NULL;
+ if (dependencies_filename != NULL) {
+ file = File::Open(dependencies_filename, File::kWriteTruncate);
+ if (file == NULL) {
+ Log::PrintErr("Error: Unable to open dependencies file: %s\n\n",
+ dependencies_filename);
+ exit(kErrorExitCode);
+ }
- // Targets:
- switch (snapshot_kind) {
- case kCore:
- success &= file->Print("%s ", vm_snapshot_data_filename);
- success &= file->Print("%s ", isolate_snapshot_data_filename);
- break;
- case kScript:
- success &= file->Print("%s ", script_snapshot_filename);
- break;
- case kAppAOTAssembly:
- success &= file->Print("%s ", assembly_filename);
- break;
- case kAppAOTBlobs:
- success &= file->Print("%s ", vm_snapshot_data_filename);
- success &= file->Print("%s ", vm_snapshot_instructions_filename);
- success &= file->Print("%s ", isolate_snapshot_data_filename);
- success &= file->Print("%s ", isolate_snapshot_instructions_filename);
- break;
+ // Targets:
+ switch (snapshot_kind) {
+ case kCore:
+ success &= file->Print("%s ", vm_snapshot_data_filename);
+ success &= file->Print("%s ", isolate_snapshot_data_filename);
+ break;
+ case kScript:
+ success &= file->Print("%s ", script_snapshot_filename);
+ break;
+ case kAppAOTAssembly:
+ success &= file->Print("%s ", assembly_filename);
+ break;
+ case kAppAOTBlobs:
+ success &= file->Print("%s ", vm_snapshot_data_filename);
+ success &= file->Print("%s ", vm_snapshot_instructions_filename);
+ success &= file->Print("%s ", isolate_snapshot_data_filename);
+ success &= file->Print("%s ", isolate_snapshot_instructions_filename);
+ break;
+ }
+
+ success &= file->Print(": ");
}
- success &= file->Print(": ");
-
// Sources:
if (snapshot_kind == kScript) {
- success &= file->Print("%s ", vm_snapshot_data_filename);
- success &= file->Print("%s ", isolate_snapshot_data_filename);
+ if (dependencies_filename != NULL) {
+ success &= file->Print("%s ", vm_snapshot_data_filename);
+ success &= file->Print("%s ", isolate_snapshot_data_filename);
+ }
+ if (print_dependencies) {
+ Log::Print("%s\n", vm_snapshot_data_filename);
+ Log::Print("%s\n", isolate_snapshot_data_filename);
+ }
}
for (intptr_t i = 0; i < dependencies->length(); i++) {
char* dep = dependencies->At(i);
- success &= file->Print("%s ", dep);
+ if (dependencies_filename != NULL) {
+ success &= file->Print("%s ", dep);
+ }
+ if (print_dependencies) {
+ Log::Print("%s\n", dep);
+ }
free(dep);
}
- success &= file->Print("\n");
- if (!success) {
- Log::PrintErr("Error: Unable to write dependencies file: %s\n\n",
- dependencies_filename);
- exit(kErrorExitCode);
+ if (dependencies_filename != NULL) {
+ success &= file->Print("\n");
+
+ if (!success) {
+ Log::PrintErr("Error: Unable to write dependencies file: %s\n\n",
+ dependencies_filename);
+ exit(kErrorExitCode);
+ }
+ file->Release();
}
- file->Release();
delete dependencies;
isolate_data->set_dependencies(NULL);
}
@@ -839,6 +869,7 @@
" --dependencies=<output-file> Generates a Makefile with snapshot output \n"
" files as targets and all transitive imports\n"
" as sources. \n"
+" --print_dependencies Prints all transitive imports to stdout. \n"
" --dependencies_only Don't create and output the snapshot. \n"
" \n"
" To create a core snapshot: \n"
@@ -1565,7 +1596,7 @@
const bool is_kernel_file =
TryReadKernel(app_script_name, &kernel, &kernel_length);
- if (dependencies_filename != NULL) {
+ if ((dependencies_filename != NULL) || print_dependencies) {
isolate_data->set_dependencies(new MallocGrowableArray<char*>());
}
diff --git a/runtime/include/dart_api.h b/runtime/include/dart_api.h
index 0bbb63b..918e3cc 100644
--- a/runtime/include/dart_api.h
+++ b/runtime/include/dart_api.h
@@ -620,6 +620,7 @@
bool enable_error_on_bad_type;
bool enable_error_on_bad_override;
bool use_field_guards;
+ bool use_osr;
} Dart_IsolateFlags;
/**
diff --git a/runtime/observatory/lib/src/elements/isolate_view.dart b/runtime/observatory/lib/src/elements/isolate_view.dart
index 7e7599e..8c0f186 100644
--- a/runtime/observatory/lib/src/elements/isolate_view.dart
+++ b/runtime/observatory/lib/src/elements/isolate_view.dart
@@ -389,6 +389,8 @@
..children = [
new SpanElement()
..children = [
+ // TODO(bkonyi): zones will always be empty. See
+ // issue #28885.
new SpanElement()
..text = 'zone ${index++} ',
new CurlyBlockElement(queue: _r.queue)
diff --git a/runtime/observatory/lib/src/service/object.dart b/runtime/observatory/lib/src/service/object.dart
index 1618aed..954f24e 100644
--- a/runtime/observatory/lib/src/service/object.dart
+++ b/runtime/observatory/lib/src/service/object.dart
@@ -3107,6 +3107,8 @@
String _kindString;
int get memoryHighWatermark => _memoryHighWatermark;
int _memoryHighWatermark;
+
+ // TODO(bkonyi): zones will always be empty. See issue #28885.
List<Zone> get zones => _zones;
final List<Zone> _zones = new List<Zone>();
@@ -3114,7 +3116,6 @@
void _update(Map map, bool mapIsRef) {
String rawKind = map['kind'];
- List<Map> zoneList = map['zones'];
switch(rawKind) {
case "kUnknownTask":
@@ -3146,13 +3147,6 @@
}
_memoryHighWatermark = int.parse(map['_memoryHighWatermark']);
-
- zones.clear();
- zoneList.forEach((zone) {
- int capacity = zone['capacity'];
- int used = zone['used'];
- zones.add(new Zone(capacity, used));
- });
}
}
diff --git a/runtime/vm/BUILD.gn b/runtime/vm/BUILD.gn
index 19ba41f..3d1c34a 100644
--- a/runtime/vm/BUILD.gn
+++ b/runtime/vm/BUILD.gn
@@ -369,7 +369,6 @@
assert(defined(invoker.libraries), "Need libraries in $target_name")
concatenation_target_names = []
- concatenation_files = []
# Concatenate vm library patches.
foreach(library, invoker.libraries) {
@@ -381,7 +380,6 @@
output = target_output
}
concatenation_target_names += [ ":concatenate_${name}_patch" ]
- concatenation_files += [ target_output ]
}
# Build the patched sdk out of the concatenated patches and the special
@@ -397,57 +395,16 @@
script = "../../tools/patch_sdk.py"
- # We list all files which make up the sdk (modulo patches) and get them
- # back as a GN list object.
- shared_sdk_sources = exec_script("../../tools/list_dart_files.py",
- [
- "absolute",
- rebase_path("../../sdk/lib"),
- ],
- "list lines")
-
- front_end_sources = exec_script("../../tools/list_dart_files.py",
- [
- "absolute",
- rebase_path("../../pkg/front_end"),
- ],
- "list lines")
-
- kernel_sources = exec_script("../../tools/list_dart_files.py",
- [
- "absolute",
- rebase_path("../../pkg/kernel"),
- ],
- "list lines")
-
# We list the `patch_sdk.dart` tool here because the [script] (which is
# implicitly an input) will call it.
inputs = [
"../../tools/patch_sdk.dart",
]
-
- # Files below are not patches, they will not be in [concatenation_files]
- # but the `patch_sdk.dart` script will copy them into the patched sdk.
- inputs += [
- "../bin/builtin.dart",
- "../bin/vmservice/vmservice_io.dart",
- "../bin/vmservice/loader.dart",
- "../bin/vmservice/server.dart",
- ]
-
- # Add all the normal sdk sources.
- inputs += shared_sdk_sources
-
- # Add all the concatenated patch files.
- inputs += concatenation_files
-
- # Add some front-end dependencies
- inputs += front_end_sources
- inputs += kernel_sources
+ depfile = "$root_out_dir/patched_sdk.d"
outputs = [
# Instead of listing all outputs we list a single well-known one.
- "${patched_sdk_dir}/lib/core/core.dart",
+ "${patched_sdk_dir}/platform.dill",
]
args = [ "--quiet" ]
diff --git a/runtime/vm/clustered_snapshot.cc b/runtime/vm/clustered_snapshot.cc
index 3bd1c6c..dc9e0fe 100644
--- a/runtime/vm/clustered_snapshot.cc
+++ b/runtime/vm/clustered_snapshot.cc
@@ -5033,7 +5033,7 @@
intptr_t buffer_len = OS::StrNLen(features, PendingBytes());
if ((buffer_len != expected_len) ||
strncmp(features, expected_features, expected_len)) {
- const intptr_t kMessageBufferSize = 256;
+ const intptr_t kMessageBufferSize = 1024;
char message_buffer[kMessageBufferSize];
char* actual_features =
OS::StrNDup(features, buffer_len < 128 ? buffer_len : 128);
diff --git a/runtime/vm/code_generator.cc b/runtime/vm/code_generator.cc
index f549231..72e3aae 100644
--- a/runtime/vm/code_generator.cc
+++ b/runtime/vm/code_generator.cc
@@ -1668,7 +1668,7 @@
}
if ((stack_overflow_flags & Thread::kOsrRequest) != 0) {
- ASSERT(FLAG_use_osr);
+ ASSERT(isolate->use_osr());
DartFrameIterator iterator;
StackFrame* frame = iterator.NextFrame();
ASSERT(frame != NULL);
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index 5a6a1b9..4c4a87d 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -669,15 +669,13 @@
if (Snapshot::IncludesCode(kind)) {
// Checked mode affects deopt ids.
- const bool asserts =
- (isolate != NULL) ? isolate->asserts() : FLAG_enable_asserts;
- const bool type_checks =
- (isolate != NULL) ? isolate->type_checks() : FLAG_enable_type_checks;
- const bool field_guards =
- (isolate != NULL) ? isolate->use_field_guards() : FLAG_use_field_guards;
- buffer.AddString(asserts ? " asserts" : " no-asserts");
- buffer.AddString(type_checks ? " type-checks" : " no-type-checks");
- buffer.AddString(field_guards ? "field-guards" : "no-field-guards");
+#define ADD_FLAG(name, isolate_flag, flag) \
+ do { \
+ const bool name = (isolate != NULL) ? isolate->name() : flag; \
+ buffer.AddString(name ? (" " #name) : (" no-" #name)); \
+ } while (0);
+ ISOLATE_FLAG_LIST(ADD_FLAG);
+#undef ADD_FLAG
// Generated code must match the host architecture and ABI.
#if defined(TARGET_ARCH_ARM)
diff --git a/runtime/vm/debugger_api_impl_test.cc b/runtime/vm/debugger_api_impl_test.cc
index ee47df9..24a339a 100644
--- a/runtime/vm/debugger_api_impl_test.cc
+++ b/runtime/vm/debugger_api_impl_test.cc
@@ -465,8 +465,9 @@
int saved_threshold = FLAG_optimization_counter_threshold;
const int kLowThreshold = 100;
const int kHighThreshold = 10000;
- bool saved_osr = FLAG_use_osr;
- FLAG_use_osr = false;
+ Isolate* isolate = Isolate::Current();
+ const bool saved_use_osr = isolate->use_osr();
+ isolate->set_use_osr(false);
if (optimize) {
// Warm up the code to make sure it gets optimized. We ignore any
@@ -511,7 +512,7 @@
}
FLAG_optimization_counter_threshold = saved_threshold;
- FLAG_use_osr = saved_osr;
+ isolate->set_use_osr(saved_use_osr);
}
diff --git a/runtime/vm/flag_list.h b/runtime/vm/flag_list.h
index 5831114..be174f0 100644
--- a/runtime/vm/flag_list.h
+++ b/runtime/vm/flag_list.h
@@ -25,6 +25,12 @@
#define USING_MULTICORE false
#endif
+#if defined(DART_PRECOMPILER)
+#define USING_PRECOMPILER true
+#else
+#define USING_PRECOMPILER false
+#endif
+
// List of all flags in the VM.
// Flags can be one of three categories:
// * P roduct flags: Can be set in any of the deployment modes, including in
@@ -162,7 +168,7 @@
"Use class hierarchy analysis even if it can cause deoptimization.") \
P(use_field_guards, bool, !USING_DBC, \
"Use field guards and track field types") \
- C(use_osr, false, true, bool, true, "Use OSR") \
+ C(use_osr, false, !USING_PRECOMPILER, bool, !USING_PRECOMPILER, "Use OSR") \
P(verbose_gc, bool, false, "Enables verbose GC.") \
P(verbose_gc_hdr, int, 40, "Print verbose GC header interval.") \
R(verify_after_gc, false, bool, false, \
diff --git a/runtime/vm/flow_graph_compiler.cc b/runtime/vm/flow_graph_compiler.cc
index 1aa4347..4610cd6 100644
--- a/runtime/vm/flow_graph_compiler.cc
+++ b/runtime/vm/flow_graph_compiler.cc
@@ -333,7 +333,7 @@
bool FlowGraphCompiler::CanOSRFunction() const {
- return FLAG_use_osr & CanOptimizeFunction() && !is_optimizing();
+ return isolate()->use_osr() && CanOptimizeFunction() && !is_optimizing();
}
diff --git a/runtime/vm/hash_map.h b/runtime/vm/hash_map.h
index c9eb941..ff47301 100644
--- a/runtime/vm/hash_map.h
+++ b/runtime/vm/hash_map.h
@@ -175,8 +175,8 @@
if (array_index_ < map_.array_size_) {
// If we're not in the middle of a list, find the next array slot.
if (list_index_ == kNil) {
- while (KeyValueTrait::ValueOf(map_.array_[array_index_].kv) == kNoValue &&
- array_index_ < map_.array_size_) {
+ while ((array_index_ < map_.array_size_) &&
+ KeyValueTrait::ValueOf(map_.array_[array_index_].kv) == kNoValue) {
array_index_++;
}
if (array_index_ < map_.array_size_) {
diff --git a/runtime/vm/intermediate_language_arm.cc b/runtime/vm/intermediate_language_arm.cc
index a327937..ea29a8a 100644
--- a/runtime/vm/intermediate_language_arm.cc
+++ b/runtime/vm/intermediate_language_arm.cc
@@ -2949,7 +2949,7 @@
: instruction_(instruction) {}
virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
- if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
+ if (compiler->isolate()->use_osr() && osr_entry_label()->IsLinked()) {
const Register value = instruction_->locs()->temp(0).reg();
__ Comment("CheckStackOverflowSlowPathOsr");
__ Bind(osr_entry_label());
@@ -2968,7 +2968,8 @@
instruction_->token_pos(), instruction_->deopt_id(),
kStackOverflowRuntimeEntry, 0, instruction_->locs());
- if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
+ if (compiler->isolate()->use_osr() && !compiler->is_optimizing() &&
+ instruction_->in_loop()) {
// In unoptimized code, record loop stack checks as possible OSR entries.
compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
instruction_->deopt_id(),
@@ -2980,7 +2981,7 @@
}
Label* osr_entry_label() {
- ASSERT(FLAG_use_osr);
+ ASSERT(Isolate::Current()->use_osr());
return &osr_entry_label_;
}
diff --git a/runtime/vm/intermediate_language_arm64.cc b/runtime/vm/intermediate_language_arm64.cc
index 0d78d48..1f2a9b2 100644
--- a/runtime/vm/intermediate_language_arm64.cc
+++ b/runtime/vm/intermediate_language_arm64.cc
@@ -2642,7 +2642,7 @@
: instruction_(instruction) {}
virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
- if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
+ if (compiler->isolate()->use_osr() && osr_entry_label()->IsLinked()) {
const Register value = instruction_->locs()->temp(0).reg();
__ Comment("CheckStackOverflowSlowPathOsr");
__ Bind(osr_entry_label());
@@ -2661,7 +2661,8 @@
instruction_->token_pos(), instruction_->deopt_id(),
kStackOverflowRuntimeEntry, 0, instruction_->locs());
- if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
+ if (compiler->isolate()->use_osr() && !compiler->is_optimizing() &&
+ instruction_->in_loop()) {
// In unoptimized code, record loop stack checks as possible OSR entries.
compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
instruction_->deopt_id(),
@@ -2673,7 +2674,7 @@
}
Label* osr_entry_label() {
- ASSERT(FLAG_use_osr);
+ ASSERT(Isolate::Current()->use_osr());
return &osr_entry_label_;
}
diff --git a/runtime/vm/intermediate_language_ia32.cc b/runtime/vm/intermediate_language_ia32.cc
index e19bbf1..1f4f419 100644
--- a/runtime/vm/intermediate_language_ia32.cc
+++ b/runtime/vm/intermediate_language_ia32.cc
@@ -2565,7 +2565,7 @@
: instruction_(instruction) {}
virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
- if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
+ if (compiler->isolate()->use_osr() && osr_entry_label()->IsLinked()) {
__ Comment("CheckStackOverflowSlowPathOsr");
__ Bind(osr_entry_label());
__ movl(Address(THR, Thread::stack_overflow_flags_offset()),
@@ -2583,7 +2583,8 @@
instruction_->token_pos(), instruction_->deopt_id(),
kStackOverflowRuntimeEntry, 0, instruction_->locs());
- if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
+ if (compiler->isolate()->use_osr() && !compiler->is_optimizing() &&
+ instruction_->in_loop()) {
// In unoptimized code, record loop stack checks as possible OSR entries.
compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
instruction_->deopt_id(),
@@ -2595,7 +2596,7 @@
}
Label* osr_entry_label() {
- ASSERT(FLAG_use_osr);
+ ASSERT(Isolate::Current()->use_osr());
return &osr_entry_label_;
}
diff --git a/runtime/vm/intermediate_language_mips.cc b/runtime/vm/intermediate_language_mips.cc
index 36217a4..51882f8 100644
--- a/runtime/vm/intermediate_language_mips.cc
+++ b/runtime/vm/intermediate_language_mips.cc
@@ -2778,7 +2778,7 @@
: instruction_(instruction) {}
virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
- if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
+ if (compiler->isolate()->use_osr() && osr_entry_label()->IsLinked()) {
Register value = instruction_->locs()->temp(0).reg();
__ Comment("CheckStackOverflowSlowPathOsr");
__ Bind(osr_entry_label());
@@ -2797,7 +2797,8 @@
instruction_->token_pos(), instruction_->deopt_id(),
kStackOverflowRuntimeEntry, 0, instruction_->locs());
- if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
+ if (compiler->isolate()->use_osr() && !compiler->is_optimizing() &&
+ instruction_->in_loop()) {
// In unoptimized code, record loop stack checks as possible OSR entries.
compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
instruction_->deopt_id(),
@@ -2809,7 +2810,7 @@
}
Label* osr_entry_label() {
- ASSERT(FLAG_use_osr);
+ ASSERT(Isolate::Current()->use_osr());
return &osr_entry_label_;
}
diff --git a/runtime/vm/intermediate_language_x64.cc b/runtime/vm/intermediate_language_x64.cc
index 0193a09..c704319 100644
--- a/runtime/vm/intermediate_language_x64.cc
+++ b/runtime/vm/intermediate_language_x64.cc
@@ -2632,7 +2632,7 @@
: instruction_(instruction) {}
virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
- if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
+ if (compiler->isolate()->use_osr() && osr_entry_label()->IsLinked()) {
__ Comment("CheckStackOverflowSlowPathOsr");
__ Bind(osr_entry_label());
__ movq(Address(THR, Thread::stack_overflow_flags_offset()),
@@ -2650,7 +2650,8 @@
instruction_->token_pos(), instruction_->deopt_id(),
kStackOverflowRuntimeEntry, 0, instruction_->locs());
- if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
+ if (compiler->isolate()->use_osr() && !compiler->is_optimizing() &&
+ instruction_->in_loop()) {
// In unoptimized code, record loop stack checks as possible OSR entries.
compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
instruction_->deopt_id(),
@@ -2663,7 +2664,7 @@
Label* osr_entry_label() {
- ASSERT(FLAG_use_osr);
+ ASSERT(Isolate::Current()->use_osr());
return &osr_entry_label_;
}
diff --git a/runtime/vm/isolate.cc b/runtime/vm/isolate.cc
index af870e9..b473061 100644
--- a/runtime/vm/isolate.cc
+++ b/runtime/vm/isolate.cc
@@ -722,31 +722,27 @@
void Isolate::FlagsInitialize(Dart_IsolateFlags* api_flags) {
api_flags->version = DART_FLAGS_CURRENT_VERSION;
- api_flags->enable_type_checks = FLAG_enable_type_checks;
- api_flags->enable_asserts = FLAG_enable_asserts;
- api_flags->enable_error_on_bad_type = FLAG_error_on_bad_type;
- api_flags->enable_error_on_bad_override = FLAG_error_on_bad_override;
- api_flags->use_field_guards = FLAG_use_field_guards;
+#define INIT_FROM_FLAG(name, isolate_flag, flag) api_flags->isolate_flag = flag;
+ ISOLATE_FLAG_LIST(INIT_FROM_FLAG)
+#undef INIT_FROM_FLAG
}
void Isolate::FlagsCopyTo(Dart_IsolateFlags* api_flags) const {
api_flags->version = DART_FLAGS_CURRENT_VERSION;
- api_flags->enable_type_checks = type_checks();
- api_flags->enable_asserts = asserts();
- api_flags->enable_error_on_bad_type = error_on_bad_type();
- api_flags->enable_error_on_bad_override = error_on_bad_override();
- api_flags->use_field_guards = use_field_guards();
+#define INIT_FROM_FIELD(name, isolate_flag, flag) \
+ api_flags->isolate_flag = name();
+ ISOLATE_FLAG_LIST(INIT_FROM_FIELD)
+#undef INIT_FROM_FIELD
}
#if !defined(PRODUCT)
void Isolate::FlagsCopyFrom(const Dart_IsolateFlags& api_flags) {
- type_checks_ = api_flags.enable_type_checks;
- asserts_ = api_flags.enable_asserts;
- error_on_bad_type_ = api_flags.enable_error_on_bad_type;
- error_on_bad_override_ = api_flags.enable_error_on_bad_override;
- use_field_guards_ = api_flags.use_field_guards;
+#define SET_FROM_FLAG(name, isolate_flag, flag) \
+ name##_ = api_flags.isolate_flag;
+ ISOLATE_FLAG_LIST(SET_FROM_FLAG)
+#undef SET_FROM_FLAG
// Leave others at defaults.
}
#endif // !defined(PRODUCT)
diff --git a/runtime/vm/isolate.h b/runtime/vm/isolate.h
index 3d9bf2b..e5c55b4 100644
--- a/runtime/vm/isolate.h
+++ b/runtime/vm/isolate.h
@@ -129,6 +129,19 @@
// Fixed cache for exception handler lookup.
typedef FixedCache<intptr_t, ExceptionHandlerInfo, 16> HandlerInfoCache;
+// List of Isolate flags with corresponding members of Dart_IsolateFlags and
+// corresponding global command line flags.
+//
+// V(name, Dart_IsolateFlags-member-name, command-line-flag-name)
+//
+#define ISOLATE_FLAG_LIST(V) \
+ V(type_checks, enable_type_checks, FLAG_enable_type_checks) \
+ V(asserts, enable_asserts, FLAG_enable_asserts) \
+ V(error_on_bad_type, enable_error_on_bad_type, FLAG_error_on_bad_type) \
+ V(error_on_bad_override, enable_error_on_bad_override, \
+ FLAG_error_on_bad_override) \
+ V(use_field_guards, use_field_guards, FLAG_use_field_guards) \
+ V(use_osr, use_osr, FLAG_use_osr)
class Isolate : public BaseIsolate {
public:
@@ -634,17 +647,17 @@
void FlagsCopyFrom(const Dart_IsolateFlags& api_flags);
#if defined(PRODUCT)
- bool type_checks() const { return FLAG_enable_type_checks; }
- bool asserts() const { return FLAG_enable_asserts; }
- bool error_on_bad_type() const { return FLAG_error_on_bad_type; }
- bool error_on_bad_override() const { return FLAG_error_on_bad_override; }
- bool use_field_guards() const { return FLAG_use_field_guards; }
+#define DECLARE_GETTER(name, isolate_flag_name, flag_name) \
+ bool name() const { return flag_name; }
+ ISOLATE_FLAG_LIST(DECLARE_GETTER)
+#undef DECLARE_GETTER
+ void set_use_osr(bool use_osr) { ASSERT(!use_osr); }
#else // defined(PRODUCT)
- bool type_checks() const { return type_checks_; }
- bool asserts() const { return asserts_; }
- bool error_on_bad_type() const { return error_on_bad_type_; }
- bool error_on_bad_override() const { return error_on_bad_override_; }
- bool use_field_guards() const { return use_field_guards_; }
+#define DECLARE_GETTER(name, isolate_flag_name, flag_name) \
+ bool name() const { return name##_; }
+ ISOLATE_FLAG_LIST(DECLARE_GETTER)
+#undef DECLARE_GETTER
+ void set_use_osr(bool use_osr) { use_osr_ = use_osr; }
#endif // defined(PRODUCT)
static void KillAllIsolates(LibMsgId msg_id);
@@ -770,11 +783,9 @@
// Isolate-specific flags.
#if !defined(PRODUCT)
- bool type_checks_;
- bool asserts_;
- bool error_on_bad_type_;
- bool error_on_bad_override_;
- bool use_field_guards_;
+#define DECLARE_FIELD(name, isolate_flag_name, flag_name) bool name##_;
+ ISOLATE_FLAG_LIST(DECLARE_FIELD)
+#undef DECLARE_FIELD
#endif // !defined(PRODUCT)
// Timestamps of last operation via service.
diff --git a/runtime/vm/kernel_isolate.cc b/runtime/vm/kernel_isolate.cc
index d0a09f8..0b6e867 100644
--- a/runtime/vm/kernel_isolate.cc
+++ b/runtime/vm/kernel_isolate.cc
@@ -71,15 +71,14 @@
// Note: these flags must match those passed to the VM during
// the app-jit training run (see //utils/kernel-service/BUILD.gn).
Dart_IsolateFlags api_flags;
- api_flags.version = DART_FLAGS_CURRENT_VERSION;
+ Isolate::FlagsInitialize(&api_flags);
api_flags.enable_type_checks = false;
api_flags.enable_asserts = false;
api_flags.enable_error_on_bad_type = false;
api_flags.enable_error_on_bad_override = false;
-#if defined(DART_PRECOMPILER)
- api_flags.use_field_guards = false;
-#else
+#if !defined(DART_PRECOMPILER)
api_flags.use_field_guards = true;
+ api_flags.use_osr = true;
#endif
isolate = reinterpret_cast<Isolate*>(create_callback(
diff --git a/runtime/vm/thread.cc b/runtime/vm/thread.cc
index dc54d6a..31ecabe 100644
--- a/runtime/vm/thread.cc
+++ b/runtime/vm/thread.cc
@@ -230,15 +230,6 @@
OSThread::ThreadIdToIntPtr(os_thread()->trace_id()));
jsobj.AddProperty("kind", TaskKindToCString(task_kind()));
jsobj.AddPropertyF("_memoryHighWatermark", "%" Pu "", memory_high_watermark_);
- Zone* zone = zone_;
- {
- JSONArray zone_info_array(&jsobj, "zones");
- zone = zone_;
- while (zone != NULL) {
- zone_info_array.AddValue(zone);
- zone = zone->previous();
- }
- }
}
#endif
diff --git a/runtime/vm/thread_test.cc b/runtime/vm/thread_test.cc
index 74a97fd..7905969 100644
--- a/runtime/vm/thread_test.cc
+++ b/runtime/vm/thread_test.cc
@@ -325,24 +325,9 @@
// Confirm all expected entries are in the JSON output.
for (intptr_t i = 0; i < kTaskCount + 1; i++) {
Thread* thread = threads[i];
- Zone* top_zone = thread->zone();
-
StackZone stack_zone(current_thread);
Zone* current_zone = current_thread->zone();
- // Check that all zones are present with correct sizes.
- while (top_zone != NULL) {
- char* zone_info_buf =
- OS::SCreate(current_zone,
- "\"type\":\"_Zone\","
- "\"capacity\":%" Pd
- ","
- "\"used\":%" Pd "",
- top_zone->CapacityInBytes(), top_zone->SizeInBytes());
- EXPECT_SUBSTRING(zone_info_buf, json);
- top_zone = top_zone->previous();
- }
-
// Check the thread exists and is the correct size.
char* thread_info_buf =
OS::SCreate(current_zone,
diff --git a/runtime/vm/zone.cc b/runtime/vm/zone.cc
index fc988a7..8b3cdac 100644
--- a/runtime/vm/zone.cc
+++ b/runtime/vm/zone.cc
@@ -301,6 +301,7 @@
#ifndef PRODUCT
+// TODO(bkonyi): Currently dead code. See issue #28885.
void Zone::PrintJSON(JSONStream* stream) const {
JSONObject jsobj(stream);
intptr_t capacity = CapacityInBytes();
diff --git a/tests/co19/co19-kernel.status b/tests/co19/co19-kernel.status
index c7dda2b..51f15c2 100644
--- a/tests/co19/co19-kernel.status
+++ b/tests/co19/co19-kernel.status
@@ -101,19 +101,11 @@
Language/Classes/Superclasses/Inheritance_and_Overriding/inheritance_t03: RuntimeError
Language/Classes/Superclasses/superclass_of_itself_t01: MissingCompileTimeError
Language/Classes/Superclasses/superclass_of_itself_t02: MissingCompileTimeError
-Language/Classes/Superclasses/wrong_superclass_t01: MissingCompileTimeError
-Language/Classes/Superclasses/wrong_superclass_t02: DartkCrash
-Language/Classes/Superclasses/wrong_superclass_t03: MissingCompileTimeError
-Language/Classes/Superclasses/wrong_superclass_t05: DartkCrash
Language/Classes/Superclasses/wrong_superclass_t07: Crash
Language/Classes/Superclasses/wrong_superclass_t08: MissingCompileTimeError
Language/Classes/Superinterfaces/dynamic_type_t01: MissingCompileTimeError
Language/Classes/Superinterfaces/dynamic_type_t02: MissingCompileTimeError
Language/Classes/Superinterfaces/itself_t01: MissingCompileTimeError
-Language/Classes/Superinterfaces/type_variable_as_superinterface_t01: DartkCrash
-Language/Classes/Superinterfaces/wrong_type_t01: MissingCompileTimeError
-Language/Classes/Superinterfaces/wrong_type_t02: DartkCrash
-Language/Classes/Superinterfaces/wrong_type_t03: MissingCompileTimeError
Language/Classes/Superinterfaces/wrong_type_t04: MissingCompileTimeError
Language/Classes/Superinterfaces/wrong_type_t05: MissingCompileTimeError
Language/Classes/declarations_t02: MissingCompileTimeError
@@ -308,7 +300,6 @@
Language/Expressions/Method_Invocation/Super_Invocation/invocation_t03: MissingCompileTimeError
Language/Expressions/Method_Invocation/Super_Invocation/syntax_t02: DartkCrash
Language/Expressions/Method_Invocation/Super_Invocation/syntax_t03: DartkCrash
-Language/Expressions/Numbers/extend_or_implement_double_t06: MissingCompileTimeError
Language/Expressions/Numbers/syntax_t21: MissingCompileTimeError
Language/Expressions/Numbers/syntax_t25: MissingCompileTimeError
Language/Expressions/Numbers/syntax_t26: MissingCompileTimeError
@@ -393,11 +384,9 @@
Language/Libraries_and_Scripts/Imports/namespace_changes_t27: CompileTimeError
Language/Libraries_and_Scripts/Imports/same_name_t02/01: MissingRuntimeError
Language/Libraries_and_Scripts/Imports/same_name_t05: RuntimeError
-Language/Libraries_and_Scripts/Imports/same_name_t07: MissingCompileTimeError
Language/Libraries_and_Scripts/Imports/same_name_t10: RuntimeError
Language/Libraries_and_Scripts/Imports/same_name_t12/01: MissingRuntimeError
Language/Libraries_and_Scripts/Imports/same_name_t15/01: MissingRuntimeError
-Language/Libraries_and_Scripts/Imports/same_name_t17: MissingCompileTimeError
Language/Libraries_and_Scripts/Imports/same_name_t19: RuntimeError
Language/Libraries_and_Scripts/Imports/static_type_t01: Skip # No support for deferred libraries.
Language/Libraries_and_Scripts/Imports/syntax_t32: MissingCompileTimeError
@@ -449,15 +438,11 @@
Language/Mixins/Mixin_Application/syntax_t15: MissingCompileTimeError
Language/Mixins/Mixin_Application/wrong_mixin_type_t01: MissingCompileTimeError
Language/Mixins/Mixin_Application/wrong_mixin_type_t02: MissingCompileTimeError
-Language/Mixins/Mixin_Application/wrong_mixin_type_t03: MissingCompileTimeError
-Language/Mixins/Mixin_Application/wrong_mixin_type_t04: MissingCompileTimeError
Language/Mixins/Mixin_Application/wrong_mixin_type_t05: DartkCrash
Language/Mixins/Mixin_Application/wrong_mixin_type_t06: DartkCrash
Language/Mixins/Mixin_Application/wrong_mixin_type_t07: MissingCompileTimeError
-Language/Mixins/Mixin_Application/wrong_mixin_type_t08: Crash
Language/Mixins/Mixin_Application/wrong_type_t01: MissingCompileTimeError
Language/Mixins/Mixin_Application/wrong_type_t02: DartkCrash
-Language/Mixins/Mixin_Application/wrong_type_t03: MissingCompileTimeError
Language/Mixins/Mixin_Application/wrong_type_t04: Crash
Language/Mixins/Mixin_Application/wrong_type_t05: MissingCompileTimeError
Language/Mixins/Mixin_Application/wrong_type_t06: Crash
@@ -706,6 +691,7 @@
Language/Overview/Scoping/conflicting_names_t43: Crash
Language/Overview/Scoping/hiding_declaration_t11: Crash
Language/Overview/Scoping/hiding_declaration_t12: Crash
+LibTest/isolate/Isolate/spawnUri_A01_t04: Pass, Slow, Timeout
# dartk: precompilation failures
[ $compiler == dartkp ]
@@ -749,6 +735,7 @@
Language/Expressions/Function_Invocation/Unqualified_Invocation/prefix_object_invocation_t01: MissingCompileTimeError
Language/Expressions/Identifier_Reference/evaluation_prefix_t01: MissingCompileTimeError
Language/Expressions/Identifier_Reference/evaluation_type_parameter_t02: MissingCompileTimeError
+Language/Expressions/Instance_Creation/New/syntax_t02: MissingCompileTimeError
Language/Expressions/Logical_Boolean_Expressions/syntax_t02: MissingCompileTimeError
Language/Expressions/Logical_Boolean_Expressions/syntax_t03: MissingCompileTimeError
Language/Expressions/Method_Invocation/Super_Invocation/invocation_t01: MissingCompileTimeError
@@ -766,6 +753,8 @@
Language/Expressions/This/placement_t06: MissingCompileTimeError
Language/Expressions/This/placement_t07: MissingCompileTimeError
Language/Expressions/This/placement_t08: MissingCompileTimeError
+Language/Libraries_and_Scripts/Imports/namespace_changes_t07: MissingCompileTimeError
+Language/Libraries_and_Scripts/Imports/namespace_changes_t08: MissingCompileTimeError
Language/Overview/Privacy/private_and_public_t04: RuntimeError
Language/Overview/Scoping/conflicting_names_t43: Crash
Language/Overview/Scoping/hiding_declaration_t11: Crash
diff --git a/tests/language/language_kernel.status b/tests/language/language_kernel.status
index 4d58159..c98b85d 100644
--- a/tests/language/language_kernel.status
+++ b/tests/language/language_kernel.status
@@ -323,8 +323,6 @@
export_double_same_main_test: Crash
export_main_test: Crash
export_private_test/01: MissingCompileTimeError
-extend_type_parameter2_negative_test: DartkCrash
-extend_type_parameter_negative_test: DartkCrash
external_test/11: MissingCompileTimeError
external_test/12: MissingCompileTimeError
external_test/13: MissingRuntimeError
@@ -379,7 +377,6 @@
function_type_alias5_test/02: MissingCompileTimeError
function_type_alias6_test/00: MissingCompileTimeError
function_type_alias7_test/00: MissingCompileTimeError
-function_type_alias7_test/01: DartkCrash
function_type_alias7_test/02: MissingCompileTimeError
function_type_alias9_test/00: MissingCompileTimeError
function_type_parameter2_negative_test: Crash
@@ -413,7 +410,6 @@
initializing_formal_final_test: RuntimeError
inst_field_initializer1_negative_test: Fail
instanceof3_test: RuntimeError
-interface2_negative_test: Fail
interface_cycle_test/01: MissingCompileTimeError
interface_cycle_test/02: MissingCompileTimeError
invocation_mirror_test: RuntimeError
@@ -431,22 +427,14 @@
large_class_declaration_test: SkipSlow # KernelVM Issue 28312
library_ambiguous_test/00: MissingRuntimeError
library_ambiguous_test/04: MissingRuntimeError
-library_ambiguous_test/05: MissingCompileTimeError
library_env_test/has_html_support: RuntimeError
library_env_test/has_no_io_support: RuntimeError
list_literal2_negative_test: Fail
list_literal4_test: RuntimeError
main_not_a_function_test/01: Crash
malformed2_test/00: RuntimeError
-malformed_inheritance_test/01: MissingCompileTimeError
-malformed_inheritance_test/03: Crash
-malformed_inheritance_test/05: MissingCompileTimeError
-malformed_inheritance_test/07: DartkCrash
-malformed_inheritance_test/08: DartkCrash
malformed_inheritance_test/09: MissingCompileTimeError
malformed_inheritance_test/10: MissingCompileTimeError
-malformed_inheritance_test/11: DartkCrash
-malformed_inheritance_test/12: DartkCrash
malformed_test/none: RuntimeError
map_literal2_negative_test: Fail
map_literal3_test: RuntimeError
@@ -487,11 +475,6 @@
mixin_illegal_object_test/01: MissingCompileTimeError
mixin_illegal_object_test/02: MissingCompileTimeError
mixin_illegal_syntax_test/00: DartkCrash
-mixin_invalid_inheritance1_test/01: Crash
-mixin_invalid_inheritance1_test/02: Crash
-mixin_invalid_inheritance1_test/03: Crash
-mixin_invalid_inheritance2_test/01: MissingCompileTimeError
-mixin_invalid_inheritance2_test/02: MissingCompileTimeError
mixin_invalid_inheritance2_test/03: DartkCrash
mixin_issue10216_2_test: RuntimeError
mixin_mixin2_test: RuntimeError
@@ -534,8 +517,6 @@
on_catch_malformed_type_test: RuntimeError
parameter_initializer6_negative_test: Fail
part2_test: RuntimeError
-prefix13_negative_test: Fail
-prefix15_negative_test: Fail
private_access_test/05: RuntimeError
private_access_test/06: RuntimeError
private_super_constructor_test/01: MissingCompileTimeError
@@ -656,7 +637,6 @@
vm/debug_break_enabled_vm_test/none: CompileTimeError
vm/regress_27201_test: CompileTimeError
vm/regress_27671_test: RuntimeError
-vm/regress_28325_test: RuntimeError
vm/type_cast_vm_test: RuntimeError
vm/type_vm_test: RuntimeError
@@ -718,14 +698,13 @@
super_call4_test: RuntimeError
super_getter_setter_test: RuntimeError
try_catch_syntax_test/05: MissingCompileTimeError
-vm/lazy_deopt_vm_test: Pass, Slow
-vm/lazy_deopt_vm_test: Pass, Timeout
+vm/lazy_deopt_vm_test: Pass, Slow, Timeout
vm/optimized_stacktrace_test: Skip # Issue 28788
# dartk: JIT failures (debug)
[ $compiler == dartk && $mode == debug ]
constructor_duplicate_initializers_test/03: Crash
-deopt_inlined_function_lazy_test: Timeout
+deopt_inlined_function_lazy_test: Skip
hello_dart_test: Crash # error: expected: cls.is_type_finalized()
not_enough_positional_arguments_test/02: Crash # Dartk Issue 28301
not_enough_positional_arguments_test/05: Crash # Dartk Issue 28301
@@ -739,6 +718,7 @@
ref_before_declaration_test/07: Crash
ref_before_declaration_test/none: Crash
try_catch_syntax_test/05: Crash
+vm/lazy_deopt_vm_test: Crash
# dartk: precompilation failures
[ $compiler == dartkp ]
@@ -774,6 +754,8 @@
illegal_initializer_test/04: MissingCompileTimeError
illegal_invocation_test/01: MissingCompileTimeError
label_test: RuntimeError
+named_constructor_test/05: MissingCompileTimeError
+named_constructor_test/08: MissingCompileTimeError
prefix_assignment_test/01: MissingCompileTimeError
prefix_assignment_test/02: MissingCompileTimeError
prefix_identifier_reference_test/01: MissingCompileTimeError
diff --git a/tools/VERSION b/tools/VERSION
index a5691e7..00ca6a0 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 1
MINOR 23
PATCH 0
-PRERELEASE 3
+PRERELEASE 4
PRERELEASE_PATCH 0
diff --git a/tools/deps/dartium.deps/DEPS.chromium b/tools/deps/dartium.deps/DEPS.chromium
index d15aff5..8d00973 100644
--- a/tools/deps/dartium.deps/DEPS.chromium
+++ b/tools/deps/dartium.deps/DEPS.chromium
@@ -623,17 +623,6 @@
{
'action': [
'python',
- 'src/third_party/mojo/src/mojo/public/tools/download_shell_binary.py',
- '--tools-directory=../../../../../../tools'
- ],
- 'pattern':
- '',
- 'name':
- 'download_mojo_shell'
- },
- {
- 'action': [
- 'python',
'src/third_party/instrumented_libraries/scripts/download_binaries.py'
],
'pattern':
diff --git a/tools/patch_sdk.dart b/tools/patch_sdk.dart
index 33a06fb..bcdc635 100644
--- a/tools/patch_sdk.dart
+++ b/tools/patch_sdk.dart
@@ -13,8 +13,41 @@
import 'package:analyzer/analyzer.dart';
import 'package:analyzer/src/generated/sdk.dart';
import 'package:path/path.dart' as path;
-import 'package:front_end/src/fasta/compile_platform.dart' as
- compile_platform;
+import 'package:front_end/src/fasta/compile_platform.dart' as compile_platform;
+
+import 'package:front_end/src/fasta/outline.dart' show CompileTask;
+
+import 'package:front_end/src/fasta/compiler_command_line.dart'
+ show CompilerCommandLine;
+
+import 'package:front_end/src/fasta/compiler_context.dart' show CompilerContext;
+
+import 'package:front_end/src/fasta/ticker.dart' show Ticker;
+
+/// Set of input files that were read by this script to generate patched SDK.
+/// We will dump it out into the depfile for ninja to use.
+///
+/// For more information see GN and Ninja references:
+/// https://chromium.googlesource.com/chromium/src/+/56807c6cb383140af0c03da8f6731d77785d7160/tools/gn/docs/reference.md#depfile_string_File-name-for-input-dependencies-for-actions
+/// https://ninja-build.org/manual.html#_depfile
+///
+final deps = new Set<String>();
+
+/// Create [File] object from the given path and register it as a dependency.
+File getInputFile(String path, {canBeMissing: false}) {
+ final file = new File(path);
+ if (!file.existsSync()) {
+ if (!canBeMissing) throw "patch_sdk.dart expects all inputs to exist";
+ return null;
+ }
+ deps.add(file.absolute.path);
+ return file;
+}
+
+/// Read the given file synchronously as a string and register this path as
+/// a dependency.
+String readInputFile(String path, {canBeMissing: false}) =>
+ getInputFile(path, canBeMissing: canBeMissing)?.readAsStringSync();
Future main(List<String> argv) async {
var base = path.fromUri(Platform.script);
@@ -28,8 +61,8 @@
final sdkExample = path.relative(path.join(repositoryDir, 'sdk'));
final patchExample = path.relative(
path.join(repositoryDir, 'out', 'DebugX64', 'obj', 'gen', 'patch'));
- final outExample = path.relative(path.join(repositoryDir, 'out', 'DebugX64',
- 'obj', 'gen', 'patched_sdk'));
+ final outExample = path.relative(path.join(
+ repositoryDir, 'out', 'DebugX64', 'obj', 'gen', 'patched_sdk'));
print('For example:');
print('\$ $self vm $sdkExample $patchExample $outExample');
@@ -37,6 +70,7 @@
}
var mode = argv[0];
+ assert(mode == "vm");
var input = argv[1];
var sdkLibIn = path.join(input, 'lib');
var patchIn = argv[2];
@@ -48,12 +82,11 @@
var INTERNAL_PATH = '_internal/compiler/js_lib/';
// Copy and patch libraries.dart and version
- var libContents = new File(path.join(sdkLibIn, '_internal',
- 'sdk_library_metadata', 'lib', 'libraries.dart')).readAsStringSync();
- if (mode == 'vm') {
- libContents = libContents.replaceAll(
- ' libraries = const {',
- ''' libraries = const {
+ var libContents = readInputFile(path.join(
+ sdkLibIn, '_internal', 'sdk_library_metadata', 'lib', 'libraries.dart'));
+ libContents = libContents.replaceAll(
+ ' libraries = const {',
+ ''' libraries = const {
"_builtin": const LibraryInfo(
"_builtin/_builtin.dart",
@@ -80,39 +113,25 @@
platforms: VM_PLATFORM),
''');
- }
_writeSync(
path.join(
sdkOut, '_internal', 'sdk_library_metadata', 'lib', 'libraries.dart'),
libContents);
- if (mode == 'ddc') {
- _writeSync(path.join(sdkOut, '..', 'version'),
- new File(path.join(sdkLibIn, '..', 'version')).readAsStringSync());
- }
// Parse libraries.dart
var sdkLibraries = _getSdkLibraries(libContents);
// Enumerate core libraries and apply patches
for (SdkLibrary library in sdkLibraries) {
- // TODO(jmesserly): analyzer does not handle the default case of
- // "both platforms" correctly, and treats it as being supported on neither.
- // So instead we skip explicitly marked as either VM or dart2js libs.
- if (mode == 'ddc' ? library.isVmLibrary : library.isDart2JsLibrary) {
+ if (library.isDart2JsLibrary) {
continue;
}
var libraryOut = path.join(sdkLibIn, library.path);
- var libraryIn;
- if (mode == 'ddc' && library.path.contains(INTERNAL_PATH)) {
- libraryIn =
- path.join(privateIn, library.path.replaceAll(INTERNAL_PATH, ''));
- } else {
- libraryIn = libraryOut;
- }
+ var libraryIn = libraryOut;
- var libraryFile = new File(libraryIn);
- if (libraryFile.existsSync()) {
+ var libraryFile = getInputFile(libraryIn, canBeMissing: true);
+ if (libraryFile != null) {
var outPaths = <String>[libraryOut];
var libraryContents = libraryFile.readAsStringSync();
@@ -124,7 +143,8 @@
var partPath = part.uri.stringValue;
outPaths.add(path.join(path.dirname(libraryOut), partPath));
- var partFile = new File(path.join(path.dirname(libraryIn), partPath));
+ var partFile =
+ getInputFile(path.join(path.dirname(libraryIn), partPath));
partFiles.add(partFile);
inputModifyTime = math.max(inputModifyTime,
partFile.lastModifiedSync().millisecondsSinceEpoch);
@@ -135,9 +155,8 @@
var patchPath = path.join(
patchIn, path.basenameWithoutExtension(libraryIn) + '_patch.dart');
- var patchFile = new File(patchPath);
- bool patchExists = patchFile.existsSync();
- if (patchExists) {
+ var patchFile = getInputFile(patchPath, canBeMissing: true);
+ if (patchFile != null) {
inputModifyTime = math.max(inputModifyTime,
patchFile.lastModifiedSync().millisecondsSinceEpoch);
}
@@ -162,10 +181,9 @@
if (needsUpdate) {
var contents = <String>[libraryContents];
contents.addAll(partFiles.map((f) => f.readAsStringSync()));
- if (patchExists) {
+ if (patchFile != null) {
var patchContents = patchFile.readAsStringSync();
- contents = _patchLibrary(
- patchFile.path, contents, patchContents);
+ contents = _patchLibrary(patchFile.path, contents, patchContents);
}
for (var i = 0; i < outPaths.length; i++) {
@@ -175,22 +193,22 @@
}
}
- if (mode == 'vm') {
- for (var tuple in [['_builtin', 'builtin.dart']]) {
- var vmLibrary = tuple[0];
- var dartFile = tuple[1];
+ for (var tuple in [
+ ['_builtin', 'builtin.dart']
+ ]) {
+ var vmLibrary = tuple[0];
+ var dartFile = tuple[1];
- // The "dart:_builtin" library is only available for the DartVM.
- var builtinLibraryIn = path.join(dartDir, 'runtime', 'bin', dartFile);
- var builtinLibraryOut = path.join(sdkOut, vmLibrary, '${vmLibrary}.dart');
- _writeSync(builtinLibraryOut, new File(builtinLibraryIn).readAsStringSync());
- }
+ // The "dart:_builtin" library is only available for the DartVM.
+ var builtinLibraryIn = path.join(dartDir, 'runtime', 'bin', dartFile);
+ var builtinLibraryOut = path.join(sdkOut, vmLibrary, '${vmLibrary}.dart');
+ _writeSync(builtinLibraryOut, readInputFile(builtinLibraryIn));
+ }
- for (var file in ['loader.dart', 'server.dart', 'vmservice_io.dart']) {
- var libraryIn = path.join(dartDir, 'runtime', 'bin', 'vmservice', file);
- var libraryOut = path.join(sdkOut, 'vmservice_io', file);
- _writeSync(libraryOut, new File(libraryIn).readAsStringSync());
- }
+ for (var file in ['loader.dart', 'server.dart', 'vmservice_io.dart']) {
+ var libraryIn = path.join(dartDir, 'runtime', 'bin', 'vmservice', file);
+ var libraryOut = path.join(sdkOut, 'vmservice_io', file);
+ _writeSync(libraryOut, readInputFile(libraryIn));
}
// TODO(kustermann): We suppress compiler hints/warnings/errors temporarily
@@ -199,13 +217,49 @@
// been fixed (either in fasta or the dart files in the patched_sdk).
final capturedLines = <String>[];
try {
+ final platform = path.join(outDir, 'platform.dill');
+
await runZoned(() async {
await compile_platform.mainEntryPoint(<String>[
'--packages',
new Uri.file(packagesFile).toString(),
new Uri.directory(outDir).toString(),
- path.join(outDir, 'platform.dill')
+ platform,
]);
+
+ // platform.dill was generated, now generate platform.dill.d depfile
+ // that captures all dependencies that participated in the generation.
+ // There are two types of dependencies:
+ // (1) all Dart sources that constitute this tool itself
+ // (2) Dart SDK and patch sources.
+ // We already collected all inputs from the second category in the deps
+ // set. To collect inputs from the first category we actually use Fasta:
+ // we ask Fasta to outline patch_sdk.dart and generate a depfile which
+ // would list all the sources.
+ final depfile = "${outDir}.d";
+ await CompilerCommandLine.withGlobalOptions("outline", [
+ '--packages',
+ new Uri.file(packagesFile).toString(),
+ '--platform',
+ new Uri.file(platform).toString(), // platform.dill
+ Platform.script.toString() // patch_sdk.dart
+ ], (CompilerContext c) async {
+ CompileTask task =
+ new CompileTask(c, new Ticker(isVerbose: c.options.verbose));
+ final kernelTarget = await task.buildOutline(null);
+ await kernelTarget.writeDepsFile(
+ new Uri.file(platform), new Uri.file(depfile));
+ });
+
+ // Read depfile generated by Fasta and append deps that we have collected
+ // during generation of patched_sdk to it.
+ // Note: we are splitting by ': ' because Windows paths can start with
+ // drive letter followed by a colon.
+ final list = new File(depfile).readAsStringSync().split(': ');
+ assert(list.length == 2);
+ deps.addAll(list[1].split(' ').where((str) => str.isNotEmpty));
+ assert(list[0] == path.join('patched_sdk', 'platform.dill'));
+ new File(depfile).writeAsStringSync("${list[0]}: ${deps.join(' ')}\n");
}, zoneSpecification: new ZoneSpecification(print: (_, _2, _3, line) {
capturedLines.add(line);
}));
@@ -244,9 +298,8 @@
/// in the Dart language. Since this feature is only for the convenience of
/// writing the dart:* libraries, and not a tool given to Dart developers, it
/// seems like a non-ideal situation. Instead we keep the preprocessing simple.
-List<String> _patchLibrary(String name,
- List<String> partsContents,
- String patchContents) {
+List<String> _patchLibrary(
+ String name, List<String> partsContents, String patchContents) {
var results = <StringEditBuffer>[];
// Parse the patch first. We'll need to extract bits of this as we go through
@@ -275,8 +328,13 @@
}
final String injectedCidFields = [
- 'Array', 'ExternalOneByteString', 'GrowableObjectArray',
- 'ImmutableArray', 'OneByteString', 'TwoByteString', 'Bigint'
+ 'Array',
+ 'ExternalOneByteString',
+ 'GrowableObjectArray',
+ 'ImmutableArray',
+ 'OneByteString',
+ 'TwoByteString',
+ 'Bigint'
].map((name) => "static final int cid${name} = 0;").join('\n');
/// Merge `@patch` declarations into `external` declarations.
@@ -302,8 +360,7 @@
// make core libraries compile. Kernel reader will actually ignore these
// fields and instead inject concrete constants into this class.
if (node is ClassDeclaration && node.name.name == 'ClassID') {
- code = code.replaceFirst(
- new RegExp(r'}$'), injectedCidFields + '}');
+ code = code.replaceFirst(new RegExp(r'}$'), injectedCidFields + '}');
}
edits.insert(pos, '\n' + code);
}
@@ -449,7 +506,8 @@
var accessor = '';
if (node is MethodDeclaration) {
- if (node.isGetter) accessor = 'get:';
+ if (node.isGetter)
+ accessor = 'get:';
else if (node.isSetter) accessor = 'set:';
}
return className + accessor + name;
diff --git a/tools/patch_sdk.py b/tools/patch_sdk.py
index 25e553e..212514a 100755
--- a/tools/patch_sdk.py
+++ b/tools/patch_sdk.py
@@ -48,7 +48,8 @@
print >> sys.stderr, 'ERROR: cannot locate dart executable'
return -1
dart_file = os.path.join(os.path.dirname(__file__), 'patch_sdk.dart')
- subprocess.check_call([options.dart_executable, dart_file] + args)
+ subprocess.check_call(
+ [options.dart_executable, '--checked', dart_file] + args)
return 0
if __name__ == '__main__':
diff --git a/tools/testing/dart/compiler_configuration.dart b/tools/testing/dart/compiler_configuration.dart
index b225c15..1f64f27 100644
--- a/tools/testing/dart/compiler_configuration.dart
+++ b/tools/testing/dart/compiler_configuration.dart
@@ -213,7 +213,7 @@
CommandArtifact artifact) {
List<String> args = [];
if (useDFE) {
- args.add('--dfe=utils/kernel-service/kernel-service.dart');
+ args.add('--dfe=${buildDir}/gen/kernel-service.dart.snapshot');
}
if (isChecked) {
args.add('--enable_asserts');
