| Index: pkg/analyzer/test/src/summary/resynthesize_test.dart
|
| diff --git a/pkg/analyzer/test/src/summary/resynthesize_test.dart b/pkg/analyzer/test/src/summary/resynthesize_test.dart
|
| deleted file mode 100644
|
| index 7f1d44bc0f82eb57afcf1cdbc0a3aba260e12e30..0000000000000000000000000000000000000000
|
| --- a/pkg/analyzer/test/src/summary/resynthesize_test.dart
|
| +++ /dev/null
|
| @@ -1,4809 +0,0 @@
|
| -// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
|
| -// for details. All rights reserved. Use of this source code is governed by a
|
| -// BSD-style license that can be found in the LICENSE file.
|
| -
|
| -library test.src.serialization.elements_test;
|
| -
|
| -import 'dart:convert';
|
| -
|
| -import 'package:analyzer/dart/ast/ast.dart';
|
| -import 'package:analyzer/dart/constant/value.dart';
|
| -import 'package:analyzer/dart/element/element.dart';
|
| -import 'package:analyzer/dart/element/type.dart';
|
| -import 'package:analyzer/error/error.dart';
|
| -import 'package:analyzer/src/dart/ast/ast.dart';
|
| -import 'package:analyzer/src/dart/element/element.dart';
|
| -import 'package:analyzer/src/dart/element/handle.dart';
|
| -import 'package:analyzer/src/dart/element/member.dart';
|
| -import 'package:analyzer/src/dart/element/type.dart';
|
| -import 'package:analyzer/src/error/codes.dart';
|
| -import 'package:analyzer/src/generated/engine.dart';
|
| -import 'package:analyzer/src/generated/resolver.dart' show Namespace;
|
| -import 'package:analyzer/src/generated/sdk.dart';
|
| -import 'package:analyzer/src/generated/source.dart';
|
| -import 'package:analyzer/src/generated/testing/ast_factory.dart';
|
| -import 'package:analyzer/src/summary/idl.dart';
|
| -import 'package:analyzer/src/summary/resynthesize.dart';
|
| -import 'package:analyzer/src/summary/summarize_elements.dart';
|
| -import 'package:test_reflective_loader/test_reflective_loader.dart';
|
| -import 'package:unittest/unittest.dart';
|
| -
|
| -import '../../generated/test_support.dart';
|
| -import '../abstract_single_unit.dart';
|
| -import '../context/abstract_context.dart';
|
| -import 'summary_common.dart' show canonicalize;
|
| -
|
| -main() {
|
| - groupSep = ' | ';
|
| - defineReflectiveTests(ResynthesizeElementTest);
|
| -}
|
| -
|
| -/**
|
| - * Abstract base class for resynthesizing and comparing elements.
|
| - */
|
| -abstract class AbstractResynthesizeTest extends AbstractSingleUnitTest {
|
| - Set<Source> otherLibrarySources = new Set<Source>();
|
| -
|
| - /**
|
| - * Names of variables which have initializers that are not valid constants,
|
| - * so they are not resynthesized.
|
| - */
|
| - Set<String> variablesWithNotConstInitializers = new Set<String>();
|
| -
|
| - /**
|
| - * Tests may set this to `true` to indicate that a missing file at the time of
|
| - * summary resynthesis shouldn't trigger an error.
|
| - */
|
| - bool allowMissingFiles = false;
|
| -
|
| - bool get checkPropagatedTypes => true;
|
| -
|
| - void addLibrary(String uri) {
|
| - otherLibrarySources.add(context.sourceFactory.forUri(uri));
|
| - }
|
| -
|
| - Source addLibrarySource(String filePath, String contents) {
|
| - Source source = addSource(filePath, contents);
|
| - otherLibrarySources.add(source);
|
| - return source;
|
| - }
|
| -
|
| - void assertNoErrors(Source source) {
|
| - GatheringErrorListener errorListener = new GatheringErrorListener();
|
| - for (AnalysisError error in context.computeErrors(source)) {
|
| - expect(error.source, source);
|
| - ErrorCode errorCode = error.errorCode;
|
| - if (errorCode == HintCode.UNUSED_ELEMENT ||
|
| - errorCode == HintCode.UNUSED_FIELD) {
|
| - continue;
|
| - }
|
| - if (errorCode == HintCode.UNUSED_CATCH_CLAUSE ||
|
| - errorCode == HintCode.UNUSED_CATCH_STACK ||
|
| - errorCode == HintCode.UNUSED_LOCAL_VARIABLE) {
|
| - continue;
|
| - }
|
| - errorListener.onError(error);
|
| - }
|
| - errorListener.assertNoErrors();
|
| - }
|
| -
|
| - /**
|
| - * Verify that the given prefix is safe to elide from a resynthesized AST.
|
| - */
|
| - void checkElidablePrefix(SimpleIdentifier prefix) {
|
| - if (prefix.staticElement is! PrefixElement &&
|
| - prefix.staticElement is! ClassElement) {
|
| - fail('Prefix of type ${prefix.staticElement.runtimeType}'
|
| - ' should not have been elided');
|
| - }
|
| - }
|
| -
|
| - void checkLibraryElements(
|
| - LibraryElementImpl original, LibraryElementImpl resynthesized) {
|
| - compareElements(resynthesized, original, '(library)');
|
| - expect(resynthesized.displayName, original.displayName);
|
| - expect(original.enclosingElement, isNull);
|
| - expect(resynthesized.enclosingElement, isNull);
|
| - expect(resynthesized.hasExtUri, original.hasExtUri);
|
| - compareCompilationUnitElements(resynthesized.definingCompilationUnit,
|
| - original.definingCompilationUnit);
|
| - expect(resynthesized.parts.length, original.parts.length, reason: 'parts');
|
| - for (int i = 0; i < resynthesized.parts.length; i++) {
|
| - compareCompilationUnitElements(resynthesized.parts[i], original.parts[i]);
|
| - }
|
| - expect(resynthesized.imports.length, original.imports.length,
|
| - reason: 'imports');
|
| - for (int i = 0; i < resynthesized.imports.length; i++) {
|
| - ImportElement originalImport = original.imports[i];
|
| - compareImportElements(
|
| - resynthesized.imports[i], originalImport, originalImport.toString());
|
| - }
|
| - expect(resynthesized.exports.length, original.exports.length,
|
| - reason: 'exports');
|
| - for (int i = 0; i < resynthesized.exports.length; i++) {
|
| - ExportElement originalExport = original.exports[i];
|
| - compareExportElements(
|
| - resynthesized.exports[i], originalExport, originalExport.toString());
|
| - }
|
| - expect(resynthesized.nameLength, original.nameLength);
|
| - compareNamespaces(resynthesized.publicNamespace, original.publicNamespace,
|
| - '(public namespace)');
|
| - compareNamespaces(resynthesized.exportNamespace, original.exportNamespace,
|
| - '(export namespace)');
|
| - if (original.entryPoint == null) {
|
| - expect(resynthesized.entryPoint, isNull);
|
| - } else {
|
| - expect(resynthesized.entryPoint, isNotNull);
|
| - compareFunctionElements(
|
| - resynthesized.entryPoint, original.entryPoint, '(entry point)');
|
| - }
|
| - // The libraries `dart:core` and `dart:async` cannot create their
|
| - // `loadLibrary` functions until after both are created.
|
| - if (original.name != 'dart.core' && original.name != 'dart.async') {
|
| - compareExecutableElements(
|
| - resynthesized.loadLibraryFunction as ExecutableElementImpl,
|
| - original.loadLibraryFunction as ExecutableElementImpl,
|
| - '(loadLibraryFunction)');
|
| - }
|
| - expect(resynthesized.libraryCycle.toSet(), original.libraryCycle.toSet());
|
| - }
|
| -
|
| - /**
|
| - * Verify that the [resynthesizer] didn't do any unnecessary work when
|
| - * resynthesizing [library].
|
| - */
|
| - void checkMinimalResynthesisWork(
|
| - TestSummaryResynthesizer resynthesizer, LibraryElement library) {
|
| - // Check that no other summaries needed to be resynthesized to resynthesize
|
| - // the library element.
|
| - expect(resynthesizer.resynthesisCount, 1);
|
| - // Check that the only linked summary consulted was that for [uri].
|
| - expect(resynthesizer.linkedSummariesRequested, hasLength(1));
|
| - expect(resynthesizer.linkedSummariesRequested.first,
|
| - library.source.uri.toString());
|
| - // Check that the only unlinked summaries consulted were those for the
|
| - // library in question.
|
| - Set<String> expectedCompilationUnitUris = library.units
|
| - .map((CompilationUnitElement unit) => unit.source.uri.toString())
|
| - .toSet();
|
| - for (String requestedUri in resynthesizer.unlinkedSummariesRequested) {
|
| - expect(expectedCompilationUnitUris, contains(requestedUri));
|
| - }
|
| - }
|
| -
|
| - void checkPossibleLocalElements(Element resynthesized, Element original) {
|
| - if (original is! LocalElement && resynthesized is! LocalElement) {
|
| - return;
|
| - }
|
| - if (original is LocalElement && resynthesized is LocalElement) {
|
| - expect(resynthesized.visibleRange, original.visibleRange);
|
| - } else {
|
| - fail('Incompatible local elements '
|
| - '${resynthesized.runtimeType} vs. ${original.runtimeType}');
|
| - }
|
| - }
|
| -
|
| - void checkPossibleMember(
|
| - Element resynthesized, Element original, String desc) {
|
| - Element resynthesizedNonHandle = resynthesized is ElementHandle
|
| - ? resynthesized.actualElement
|
| - : resynthesized;
|
| - if (original is Member) {
|
| - expect(resynthesizedNonHandle, new isInstanceOf<Member>(), reason: desc);
|
| - if (resynthesizedNonHandle is Member) {
|
| - List<DartType> resynthesizedTypeArguments =
|
| - resynthesizedNonHandle.definingType.typeArguments;
|
| - List<DartType> originalTypeArguments =
|
| - original.definingType.typeArguments;
|
| - expect(
|
| - resynthesizedTypeArguments, hasLength(originalTypeArguments.length),
|
| - reason: desc);
|
| - for (int i = 0; i < originalTypeArguments.length; i++) {
|
| - compareTypeImpls(resynthesizedTypeArguments[i],
|
| - originalTypeArguments[i], '$desc type argument $i');
|
| - }
|
| - }
|
| - } else {
|
| - expect(
|
| - resynthesizedNonHandle, isNot(new isInstanceOf<ConstructorMember>()),
|
| - reason: desc);
|
| - }
|
| - }
|
| -
|
| - void compareClassElements(ClassElement r, ClassElement o, String desc) {
|
| - compareElements(r, o, desc);
|
| - expect(r.fields.length, o.fields.length, reason: '$desc fields.length');
|
| - for (int i = 0; i < r.fields.length; i++) {
|
| - String name = o.fields[i].name;
|
| - compareFieldElements(r.fields[i], o.fields[i], '$desc.field $name');
|
| - }
|
| - compareTypes(r.supertype, o.supertype, '$desc supertype');
|
| - expect(r.interfaces.length, o.interfaces.length,
|
| - reason: '$desc interfaces.length');
|
| - for (int i = 0; i < r.interfaces.length; i++) {
|
| - compareTypes(r.interfaces[i], o.interfaces[i],
|
| - '$desc interface ${o.interfaces[i].name}');
|
| - }
|
| - expect(r.mixins.length, o.mixins.length, reason: '$desc mixins.length');
|
| - for (int i = 0; i < r.mixins.length; i++) {
|
| - compareTypes(r.mixins[i], o.mixins[i], '$desc mixin ${o.mixins[i].name}');
|
| - }
|
| - expect(r.typeParameters.length, o.typeParameters.length,
|
| - reason: '$desc typeParameters.length');
|
| - for (int i = 0; i < r.typeParameters.length; i++) {
|
| - compareTypeParameterElements(r.typeParameters[i], o.typeParameters[i],
|
| - '$desc type parameter ${o.typeParameters[i].name}');
|
| - }
|
| - expect(r.constructors.length, o.constructors.length,
|
| - reason: '$desc constructors.length');
|
| - for (int i = 0; i < r.constructors.length; i++) {
|
| - compareConstructorElements(r.constructors[i], o.constructors[i],
|
| - '$desc constructor ${o.constructors[i].name}');
|
| - }
|
| - expect(r.accessors.length, o.accessors.length,
|
| - reason: '$desc accessors.length');
|
| - List<PropertyAccessorElement> rAccessors = _getSortedPropertyAccessors(r);
|
| - List<PropertyAccessorElement> oAccessors = _getSortedPropertyAccessors(o);
|
| - for (int i = 0; i < r.accessors.length; i++) {
|
| - comparePropertyAccessorElements(
|
| - rAccessors[i], oAccessors[i], '$desc accessor ${oAccessors[i].name}');
|
| - }
|
| - expect(r.methods.length, o.methods.length, reason: '$desc methods.length');
|
| - for (int i = 0; i < r.methods.length; i++) {
|
| - compareMethodElements(
|
| - r.methods[i], o.methods[i], '$desc.${o.methods[i].name}');
|
| - }
|
| - compareTypes(r.type, o.type, desc);
|
| - if (r is ClassElementImpl && o is ClassElementImpl) {
|
| - expect(r.hasBeenInferred, o.hasBeenInferred, reason: desc);
|
| - }
|
| - }
|
| -
|
| - void compareCompilationUnitElements(CompilationUnitElementImpl resynthesized,
|
| - CompilationUnitElementImpl original) {
|
| - String desc = 'Compilation unit ${original.source.uri}';
|
| - compareUriReferencedElements(resynthesized, original, desc);
|
| - expect(resynthesized.source, original.source);
|
| - expect(resynthesized.librarySource, original.librarySource);
|
| - expect(resynthesized.types.length, original.types.length,
|
| - reason: '$desc types');
|
| - for (int i = 0; i < resynthesized.types.length; i++) {
|
| - compareClassElements(
|
| - resynthesized.types[i], original.types[i], original.types[i].name);
|
| - }
|
| - expect(resynthesized.topLevelVariables.length,
|
| - original.topLevelVariables.length,
|
| - reason: '$desc topLevelVariables');
|
| - for (int i = 0; i < resynthesized.topLevelVariables.length; i++) {
|
| - String name = resynthesized.topLevelVariables[i].name;
|
| - compareTopLevelVariableElements(
|
| - resynthesized.topLevelVariables[i],
|
| - original.topLevelVariables
|
| - .singleWhere((TopLevelVariableElement e) => e.name == name),
|
| - 'variable $name');
|
| - }
|
| - expect(resynthesized.functions.length, original.functions.length,
|
| - reason: '$desc functions');
|
| - for (int i = 0; i < resynthesized.functions.length; i++) {
|
| - compareFunctionElements(resynthesized.functions[i], original.functions[i],
|
| - 'function ${original.functions[i].name}');
|
| - }
|
| - expect(resynthesized.functionTypeAliases.length,
|
| - original.functionTypeAliases.length,
|
| - reason: '$desc functionTypeAliases');
|
| - for (int i = 0; i < resynthesized.functionTypeAliases.length; i++) {
|
| - compareFunctionTypeAliasElements(
|
| - resynthesized.functionTypeAliases[i],
|
| - original.functionTypeAliases[i],
|
| - original.functionTypeAliases[i].name);
|
| - }
|
| - expect(resynthesized.enums.length, original.enums.length,
|
| - reason: '$desc enums');
|
| - for (int i = 0; i < resynthesized.enums.length; i++) {
|
| - compareClassElements(
|
| - resynthesized.enums[i], original.enums[i], original.enums[i].name);
|
| - }
|
| - expect(resynthesized.accessors.length, original.accessors.length,
|
| - reason: '$desc accessors');
|
| - for (int i = 0; i < resynthesized.accessors.length; i++) {
|
| - String name = resynthesized.accessors[i].name;
|
| - if (original.accessors[i].isGetter) {
|
| - comparePropertyAccessorElements(
|
| - resynthesized.accessors[i],
|
| - original.accessors
|
| - .singleWhere((PropertyAccessorElement e) => e.name == name),
|
| - 'getter $name');
|
| - } else {
|
| - comparePropertyAccessorElements(
|
| - resynthesized.accessors[i],
|
| - original.accessors
|
| - .singleWhere((PropertyAccessorElement e) => e.name == name),
|
| - 'setter $name');
|
| - }
|
| - }
|
| - // Note: no need to test CompilationUnitElementImpl._offsetToElementMap
|
| - // since it is built on demand when needed (see
|
| - // CompilationUnitElementImpl.getElementAt])
|
| - }
|
| -
|
| - void compareConstAstLists(
|
| - List<Object> rItems, List<Object> oItems, String desc) {
|
| - if (rItems == null && oItems == null) {
|
| - return;
|
| - }
|
| - expect(rItems != null && oItems != null, isTrue);
|
| - expect(rItems, hasLength(oItems.length));
|
| - for (int i = 0; i < oItems.length; i++) {
|
| - Object rItem = rItems[i];
|
| - Object oItem = oItems[i];
|
| - if (rItem is Expression && oItem is Expression) {
|
| - compareConstAsts(rItem, oItem, desc);
|
| - } else if (rItem is TypeName && oItem is TypeName) {
|
| - compareConstAsts(rItem.name, oItem.name, desc);
|
| - } else if (rItem is InterpolationString && oItem is InterpolationString) {
|
| - expect(rItem.value, oItem.value);
|
| - } else if (rItem is InterpolationExpression &&
|
| - oItem is InterpolationExpression) {
|
| - compareConstAsts(rItem.expression, oItem.expression, desc);
|
| - } else if (rItem is MapLiteralEntry && oItem is MapLiteralEntry) {
|
| - compareConstAsts(rItem.key, oItem.key, desc);
|
| - compareConstAsts(rItem.value, oItem.value, desc);
|
| - } else if (oItem is ConstructorFieldInitializer &&
|
| - rItem is ConstructorFieldInitializer) {
|
| - compareConstAsts(rItem.fieldName, oItem.fieldName, desc);
|
| - if (variablesWithNotConstInitializers.contains(rItem.fieldName.name)) {
|
| - _assertUnresolvedIdentifier(rItem.expression, desc);
|
| - } else {
|
| - compareConstAsts(rItem.expression, oItem.expression, desc);
|
| - }
|
| - } else if (oItem is SuperConstructorInvocation &&
|
| - rItem is SuperConstructorInvocation) {
|
| - compareElements(rItem.staticElement, oItem.staticElement, desc);
|
| - compareConstAsts(rItem.constructorName, oItem.constructorName, desc);
|
| - compareConstAstLists(
|
| - rItem.argumentList.arguments, oItem.argumentList.arguments, desc);
|
| - } else if (oItem is RedirectingConstructorInvocation &&
|
| - rItem is RedirectingConstructorInvocation) {
|
| - compareElements(rItem.staticElement, oItem.staticElement, desc);
|
| - compareConstAsts(rItem.constructorName, oItem.constructorName, desc);
|
| - compareConstAstLists(
|
| - rItem.argumentList.arguments, oItem.argumentList.arguments, desc);
|
| - } else {
|
| - fail('$desc Incompatible item types: '
|
| - '${rItem.runtimeType} vs. ${oItem.runtimeType}');
|
| - }
|
| - }
|
| - }
|
| -
|
| - void compareConstAsts(AstNode r, AstNode o, String desc) {
|
| - if (o == null) {
|
| - expect(r, isNull, reason: desc);
|
| - } else {
|
| - expect(r, isNotNull, reason: desc);
|
| - // ConstantAstCloner does not copy static types, and constant values
|
| - // computer does not use static types. So, we don't set them during
|
| - // resynthesis and should not check them here.
|
| - if (o is ParenthesizedExpression) {
|
| - // We don't resynthesize parenthesis, so just ignore it.
|
| - compareConstAsts(r, o.expression, desc);
|
| - } else if (o is SimpleIdentifier && r is SimpleIdentifier) {
|
| - expect(r.name, o.name, reason: desc);
|
| - compareElements(r.staticElement, o.staticElement, desc);
|
| - } else if (o is PrefixedIdentifier && r is SimpleIdentifier) {
|
| - // We don't resynthesize prefixed identifiers when the prefix refers to
|
| - // a PrefixElement or a ClassElement. We use simple identifiers with
|
| - // correct elements.
|
| - if (o.prefix.staticElement is PrefixElement ||
|
| - o.prefix.staticElement is ClassElement) {
|
| - compareConstAsts(r, o.identifier, desc);
|
| - } else {
|
| - fail('Prefix of type ${o.prefix.staticElement.runtimeType} should not'
|
| - ' have been elided');
|
| - }
|
| - } else if (o is SimpleIdentifier && r is PrefixedIdentifier) {
|
| - // In 'class C {static const a = 0; static const b = a;}' the reference
|
| - // to 'a' in 'b' is serialized as a fully qualified 'C.a' reference.
|
| - if (r.prefix.staticElement is ClassElement) {
|
| - compareElements(
|
| - r.prefix.staticElement, o.staticElement?.enclosingElement, desc);
|
| - compareConstAsts(r.identifier, o, desc);
|
| - } else {
|
| - fail('Prefix of type ${r.prefix.staticElement.runtimeType} should not'
|
| - ' have been elided');
|
| - }
|
| - } else if (o is PropertyAccess &&
|
| - o.target is PrefixedIdentifier &&
|
| - r is PrefixedIdentifier) {
|
| - // We don't resynthesize prefixed identifiers when the prefix refers to
|
| - // a PrefixElement or a ClassElement. Which means that if the original
|
| - // expression was e.g. `prefix.topLevelVariableName.length`, it will get
|
| - // resynthesized as `topLevelVariableName.length`
|
| - PrefixedIdentifier oTarget = o.target;
|
| - checkElidablePrefix(oTarget.prefix);
|
| - compareConstAsts(
|
| - r, AstFactory.identifier(oTarget.identifier, o.propertyName), desc);
|
| - } else if (o is PrefixedIdentifier && r is PrefixedIdentifier) {
|
| - compareConstAsts(r.prefix, o.prefix, desc);
|
| - compareConstAsts(r.identifier, o.identifier, desc);
|
| - } else if (o is PropertyAccess && r is PropertyAccess) {
|
| - compareConstAsts(r.target, o.target, desc);
|
| - String oName = o.propertyName.name;
|
| - String rName = r.propertyName.name;
|
| - expect(rName, oName, reason: desc);
|
| - if (oName == 'length') {
|
| - compareElements(
|
| - r.propertyName.staticElement, o.propertyName.staticElement, desc);
|
| - }
|
| - } else if (o is PropertyAccess &&
|
| - o.target is PrefixedIdentifier &&
|
| - r is SimpleIdentifier) {
|
| - // We don't resynthesize property access when it takes the form
|
| - // `prefixName.className.staticMember`. We just resynthesize a
|
| - // SimpleIdentifier correctly resolved to the static member.
|
| - PrefixedIdentifier oTarget = o.target;
|
| - checkElidablePrefix(oTarget.prefix);
|
| - checkElidablePrefix(oTarget.identifier);
|
| - compareConstAsts(r, o.propertyName, desc);
|
| - } else if (o is NullLiteral) {
|
| - expect(r, new isInstanceOf<NullLiteral>(), reason: desc);
|
| - } else if (o is BooleanLiteral && r is BooleanLiteral) {
|
| - expect(r.value, o.value, reason: desc);
|
| - } else if (o is IntegerLiteral && r is IntegerLiteral) {
|
| - expect(r.value, o.value, reason: desc);
|
| - } else if (o is DoubleLiteral && r is DoubleLiteral) {
|
| - if (r.value != null &&
|
| - r.value.isNaN &&
|
| - o.value != null &&
|
| - o.value.isNaN) {
|
| - // NaN is not comparable.
|
| - } else {
|
| - expect(r.value, o.value, reason: desc);
|
| - }
|
| - } else if (o is StringInterpolation && r is StringInterpolation) {
|
| - compareConstAstLists(r.elements, o.elements, desc);
|
| - } else if (o is StringLiteral && r is StringLiteral) {
|
| - // We don't keep all the tokens of AdjacentStrings.
|
| - // So, we can compare only their values.
|
| - expect(r.stringValue, o.stringValue, reason: desc);
|
| - } else if (o is SymbolLiteral && r is SymbolLiteral) {
|
| - // We don't keep all the tokens of symbol literals.
|
| - // So, we can compare only their values.
|
| - expect(r.components.map((t) => t.lexeme).join('.'),
|
| - o.components.map((t) => t.lexeme).join('.'),
|
| - reason: desc);
|
| - } else if (o is NamedExpression && r is NamedExpression) {
|
| - expect(r.name.label.name, o.name.label.name, reason: desc);
|
| - compareConstAsts(r.expression, o.expression, desc);
|
| - } else if (o is BinaryExpression && r is BinaryExpression) {
|
| - expect(r.operator.lexeme, o.operator.lexeme, reason: desc);
|
| - compareConstAsts(r.leftOperand, o.leftOperand, desc);
|
| - compareConstAsts(r.rightOperand, o.rightOperand, desc);
|
| - } else if (o is PrefixExpression && r is PrefixExpression) {
|
| - expect(r.operator.lexeme, o.operator.lexeme, reason: desc);
|
| - compareConstAsts(r.operand, o.operand, desc);
|
| - } else if (o is ConditionalExpression && r is ConditionalExpression) {
|
| - compareConstAsts(r.condition, o.condition, desc);
|
| - compareConstAsts(r.thenExpression, o.thenExpression, desc);
|
| - compareConstAsts(r.elseExpression, o.elseExpression, desc);
|
| - } else if (o is ListLiteral && r is ListLiteral) {
|
| - compareConstAstLists(
|
| - r.typeArguments?.arguments, o.typeArguments?.arguments, desc);
|
| - compareConstAstLists(r.elements, o.elements, desc);
|
| - } else if (o is MapLiteral && r is MapLiteral) {
|
| - compareConstAstLists(
|
| - r.typeArguments?.arguments, o.typeArguments?.arguments, desc);
|
| - compareConstAstLists(r.entries, o.entries, desc);
|
| - } else if (o is MethodInvocation && r is MethodInvocation) {
|
| - compareConstAsts(r.target, o.target, desc);
|
| - compareConstAsts(r.methodName, o.methodName, desc);
|
| - compareConstAstLists(
|
| - r.typeArguments?.arguments, o.typeArguments?.arguments, desc);
|
| - compareConstAstLists(
|
| - r.argumentList?.arguments, o.argumentList?.arguments, desc);
|
| - } else if (o is InstanceCreationExpression &&
|
| - r is InstanceCreationExpression) {
|
| - compareElements(r.staticElement, o.staticElement, desc);
|
| - ConstructorName oConstructor = o.constructorName;
|
| - ConstructorName rConstructor = r.constructorName;
|
| - expect(oConstructor, isNotNull, reason: desc);
|
| - expect(rConstructor, isNotNull, reason: desc);
|
| - // Note: just compare rConstructor.staticElement and
|
| - // oConstructor.staticElement as elements, because we just want to
|
| - // check that they're pointing to the correct elements; we don't want
|
| - // to check that their constructor initializers match, because that
|
| - // could lead to infinite regress.
|
| - compareElements(
|
| - rConstructor.staticElement, oConstructor.staticElement, desc);
|
| - TypeName oType = oConstructor.type;
|
| - TypeName rType = rConstructor.type;
|
| - expect(oType, isNotNull, reason: desc);
|
| - expect(rType, isNotNull, reason: desc);
|
| - compareConstAsts(rType.name, oType.name, desc);
|
| - compareConstAsts(rConstructor.name, oConstructor.name, desc);
|
| - // In strong mode type inference is performed, so that
|
| - // `C<int> v = new C();` is serialized as `C<int> v = new C<int>();`.
|
| - // So, if there are not type arguments originally, not need to check.
|
| - if (oType.typeArguments?.arguments?.isNotEmpty ?? false) {
|
| - compareConstAstLists(rType.typeArguments?.arguments,
|
| - oType.typeArguments?.arguments, desc);
|
| - }
|
| - compareConstAstLists(
|
| - r.argumentList.arguments, o.argumentList.arguments, desc);
|
| - } else if (o is AnnotationImpl && r is AnnotationImpl) {
|
| - expect(o.atSign.lexeme, r.atSign.lexeme, reason: desc);
|
| - Identifier rName = r.name;
|
| - Identifier oName = o.name;
|
| - if (oName is PrefixedIdentifier && o.constructorName != null) {
|
| - // E.g. `@prefix.cls.ctor`. This gets resynthesized as `@cls.ctor`,
|
| - // with `cls.ctor` represented as a PrefixedIdentifier.
|
| - expect(rName, new isInstanceOf<PrefixedIdentifier>(), reason: desc);
|
| - if (rName is PrefixedIdentifier) {
|
| - compareConstAsts(rName.prefix, oName.identifier, desc);
|
| - expect(rName.period.lexeme, '.', reason: desc);
|
| - compareConstAsts(rName.identifier, o.constructorName, desc);
|
| - expect(r.period, isNull, reason: desc);
|
| - expect(r.constructorName, isNull, reason: desc);
|
| - }
|
| - } else {
|
| - compareConstAsts(r.name, o.name, desc);
|
| - expect(r.period?.lexeme, o.period?.lexeme, reason: desc);
|
| - compareConstAsts(r.constructorName, o.constructorName, desc);
|
| - }
|
| - compareConstAstLists(
|
| - r.arguments?.arguments, o.arguments?.arguments, desc);
|
| - Element expectedElement = o.element;
|
| - if (oName is PrefixedIdentifier && o.constructorName != null) {
|
| - // Due to dartbug.com/25706, [o.element] incorrectly points to the
|
| - // class rather than the named constructor. Hack around this.
|
| - // TODO(paulberry): when dartbug.com/25706 is fixed, remove this.
|
| - expectedElement = (expectedElement as ClassElement)
|
| - .getNamedConstructor(o.constructorName.name);
|
| - expect(expectedElement, isNotNull, reason: desc);
|
| - }
|
| - compareElements(r.element, expectedElement, desc);
|
| - // elementAnnotation should be null; it is only used in the full AST.
|
| - expect(o.elementAnnotation, isNull);
|
| - expect(r.elementAnnotation, isNull);
|
| - } else {
|
| - fail('Not implemented for ${r.runtimeType} vs. ${o.runtimeType}');
|
| - }
|
| - }
|
| - }
|
| -
|
| - void compareConstructorElements(ConstructorElement resynthesized,
|
| - ConstructorElement original, String desc) {
|
| - if (original == null && resynthesized == null) {
|
| - return;
|
| - }
|
| - compareExecutableElements(resynthesized, original, desc);
|
| - ConstructorElementImpl resynthesizedImpl =
|
| - getActualElement(resynthesized, desc);
|
| - ConstructorElementImpl originalImpl = getActualElement(original, desc);
|
| - if (original.isConst) {
|
| - compareConstAstLists(resynthesizedImpl.constantInitializers,
|
| - originalImpl.constantInitializers, desc);
|
| - }
|
| - if (original.redirectedConstructor == null) {
|
| - expect(resynthesized.redirectedConstructor, isNull, reason: desc);
|
| - } else {
|
| - compareConstructorElements(resynthesized.redirectedConstructor,
|
| - original.redirectedConstructor, '$desc redirectedConstructor');
|
| - }
|
| - checkPossibleMember(resynthesized, original, desc);
|
| - expect(resynthesized.nameEnd, original.nameEnd, reason: desc);
|
| - expect(resynthesized.periodOffset, original.periodOffset, reason: desc);
|
| - expect(resynthesizedImpl.isCycleFree, originalImpl.isCycleFree,
|
| - reason: desc);
|
| - }
|
| -
|
| - void compareConstValues(
|
| - DartObject resynthesized, DartObject original, String desc) {
|
| - if (original == null) {
|
| - expect(resynthesized, isNull, reason: desc);
|
| - } else {
|
| - expect(resynthesized, isNotNull, reason: desc);
|
| - compareTypes(resynthesized.type, original.type, desc);
|
| - expect(resynthesized.hasKnownValue, original.hasKnownValue, reason: desc);
|
| - if (original.isNull) {
|
| - expect(resynthesized.isNull, isTrue, reason: desc);
|
| - } else if (original.toBoolValue() != null) {
|
| - expect(resynthesized.toBoolValue(), original.toBoolValue(),
|
| - reason: desc);
|
| - } else if (original.toIntValue() != null) {
|
| - expect(resynthesized.toIntValue(), original.toIntValue(), reason: desc);
|
| - } else if (original.toDoubleValue() != null) {
|
| - expect(resynthesized.toDoubleValue(), original.toDoubleValue(),
|
| - reason: desc);
|
| - } else if (original.toListValue() != null) {
|
| - List<DartObject> resynthesizedList = resynthesized.toListValue();
|
| - List<DartObject> originalList = original.toListValue();
|
| - expect(resynthesizedList, hasLength(originalList.length));
|
| - for (int i = 0; i < originalList.length; i++) {
|
| - compareConstValues(resynthesizedList[i], originalList[i], desc);
|
| - }
|
| - } else if (original.toMapValue() != null) {
|
| - Map<DartObject, DartObject> resynthesizedMap =
|
| - resynthesized.toMapValue();
|
| - Map<DartObject, DartObject> originalMap = original.toMapValue();
|
| - expect(resynthesizedMap, hasLength(originalMap.length));
|
| - List<DartObject> resynthesizedKeys = resynthesizedMap.keys.toList();
|
| - List<DartObject> originalKeys = originalMap.keys.toList();
|
| - for (int i = 0; i < originalKeys.length; i++) {
|
| - DartObject resynthesizedKey = resynthesizedKeys[i];
|
| - DartObject originalKey = originalKeys[i];
|
| - compareConstValues(resynthesizedKey, originalKey, desc);
|
| - DartObject resynthesizedValue = resynthesizedMap[resynthesizedKey];
|
| - DartObject originalValue = originalMap[originalKey];
|
| - compareConstValues(resynthesizedValue, originalValue, desc);
|
| - }
|
| - } else if (original.toStringValue() != null) {
|
| - expect(resynthesized.toStringValue(), original.toStringValue(),
|
| - reason: desc);
|
| - } else if (original.toSymbolValue() != null) {
|
| - expect(resynthesized.toSymbolValue(), original.toSymbolValue(),
|
| - reason: desc);
|
| - } else if (original.toTypeValue() != null) {
|
| - fail('Not implemented');
|
| - }
|
| - }
|
| - }
|
| -
|
| - void compareElementAnnotations(ElementAnnotationImpl resynthesized,
|
| - ElementAnnotationImpl original, String desc) {
|
| - expect(resynthesized.element, isNotNull, reason: desc);
|
| - expect(resynthesized.element.kind, original.element.kind, reason: desc);
|
| - expect(resynthesized.element.location, original.element.location,
|
| - reason: desc);
|
| - expect(resynthesized.compilationUnit, isNotNull, reason: desc);
|
| - expect(resynthesized.compilationUnit.location,
|
| - original.compilationUnit.location,
|
| - reason: desc);
|
| - expect(resynthesized.annotationAst, isNotNull, reason: desc);
|
| - compareConstAsts(resynthesized.annotationAst, original.annotationAst, desc);
|
| - }
|
| -
|
| - void compareElements(Element resynthesized, Element original, String desc) {
|
| - ElementImpl rImpl = getActualElement(resynthesized, desc);
|
| - ElementImpl oImpl = getActualElement(original, desc);
|
| - if (oImpl == null && rImpl == null) {
|
| - return;
|
| - }
|
| - if (oImpl is PrefixElement) {
|
| - // TODO(scheglov) prefixes cannot be resynthesized
|
| - return;
|
| - }
|
| - expect(original, isNotNull);
|
| - expect(resynthesized, isNotNull, reason: desc);
|
| - if (rImpl is DefaultParameterElementImpl && oImpl is ParameterElementImpl) {
|
| - // This is ok provided the resynthesized parameter element doesn't have
|
| - // any evaluation result.
|
| - expect(rImpl.evaluationResult, isNull);
|
| - } else {
|
| - Type rRuntimeType;
|
| - if (rImpl is ConstFieldElementImpl) {
|
| - rRuntimeType = ConstFieldElementImpl;
|
| - } else if (rImpl is FunctionElementImpl) {
|
| - rRuntimeType = FunctionElementImpl;
|
| - } else {
|
| - rRuntimeType = rImpl.runtimeType;
|
| - }
|
| - expect(rRuntimeType, oImpl.runtimeType);
|
| - }
|
| - expect(resynthesized.kind, original.kind);
|
| - expect(resynthesized.location, original.location, reason: desc);
|
| - expect(resynthesized.name, original.name);
|
| - expect(resynthesized.nameOffset, original.nameOffset, reason: desc);
|
| - expect(rImpl.codeOffset, oImpl.codeOffset, reason: desc);
|
| - expect(rImpl.codeLength, oImpl.codeLength, reason: desc);
|
| - expect(resynthesized.documentationComment, original.documentationComment,
|
| - reason: desc);
|
| - compareMetadata(resynthesized.metadata, original.metadata, desc);
|
| -
|
| - // Validate modifiers.
|
| - for (Modifier modifier in Modifier.values) {
|
| - bool got = _hasModifier(resynthesized, modifier);
|
| - bool want = _hasModifier(original, modifier);
|
| - expect(got, want,
|
| - reason: 'Mismatch in $desc.$modifier: got $got, want $want');
|
| - }
|
| -
|
| - // Validate members.
|
| - if (oImpl is Member) {
|
| - expect(rImpl, new isInstanceOf<Member>(), reason: desc);
|
| - } else {
|
| - expect(rImpl, isNot(new isInstanceOf<Member>()), reason: desc);
|
| - }
|
| - }
|
| -
|
| - void compareExecutableElements(
|
| - ExecutableElement resynthesized, ExecutableElement original, String desc,
|
| - {bool shallow: false}) {
|
| - compareElements(resynthesized, original, desc);
|
| - compareParameterElementLists(
|
| - resynthesized.parameters, original.parameters, desc);
|
| - if (checkPropagatedTypes || !original.hasImplicitReturnType) {
|
| - compareTypes(
|
| - resynthesized.returnType, original.returnType, '$desc return type');
|
| - }
|
| - if (!shallow) {
|
| - compareTypes(resynthesized.type, original.type, desc);
|
| - }
|
| - expect(resynthesized.typeParameters.length, original.typeParameters.length);
|
| - for (int i = 0; i < resynthesized.typeParameters.length; i++) {
|
| - compareTypeParameterElements(
|
| - resynthesized.typeParameters[i],
|
| - original.typeParameters[i],
|
| - '$desc type parameter ${original.typeParameters[i].name}');
|
| - }
|
| - compareLocalElementsOfExecutable(resynthesized, original, desc);
|
| - }
|
| -
|
| - void compareExportElements(ExportElementImpl resynthesized,
|
| - ExportElementImpl original, String desc) {
|
| - compareUriReferencedElements(resynthesized, original, desc);
|
| - expect(resynthesized.exportedLibrary.location,
|
| - original.exportedLibrary.location);
|
| - expect(resynthesized.combinators.length, original.combinators.length);
|
| - for (int i = 0; i < resynthesized.combinators.length; i++) {
|
| - compareNamespaceCombinators(
|
| - resynthesized.combinators[i], original.combinators[i]);
|
| - }
|
| - }
|
| -
|
| - void compareFieldElements(
|
| - FieldElementImpl resynthesized, FieldElementImpl original, String desc) {
|
| - comparePropertyInducingElements(resynthesized, original, desc);
|
| - }
|
| -
|
| - void compareFunctionElements(
|
| - FunctionElement resynthesized, FunctionElement original, String desc,
|
| - {bool shallow: false}) {
|
| - if (original == null && resynthesized == null) {
|
| - return;
|
| - }
|
| - expect(resynthesized, isNotNull, reason: desc);
|
| - compareExecutableElements(resynthesized, original, desc, shallow: shallow);
|
| - checkPossibleLocalElements(resynthesized, original);
|
| - }
|
| -
|
| - void compareFunctionTypeAliasElements(
|
| - FunctionTypeAliasElementImpl resynthesized,
|
| - FunctionTypeAliasElementImpl original,
|
| - String desc) {
|
| - compareElements(resynthesized, original, desc);
|
| - compareParameterElementLists(
|
| - resynthesized.parameters, original.parameters, desc);
|
| - compareTypes(
|
| - resynthesized.returnType, original.returnType, '$desc return type');
|
| - compareTypes(resynthesized.type, original.type, desc);
|
| - expect(resynthesized.typeParameters.length, original.typeParameters.length);
|
| - for (int i = 0; i < resynthesized.typeParameters.length; i++) {
|
| - compareTypeParameterElements(
|
| - resynthesized.typeParameters[i],
|
| - original.typeParameters[i],
|
| - '$desc type parameter ${original.typeParameters[i].name}');
|
| - }
|
| - }
|
| -
|
| - void compareImportElements(ImportElementImpl resynthesized,
|
| - ImportElementImpl original, String desc) {
|
| - compareUriReferencedElements(resynthesized, original, desc);
|
| - expect(resynthesized.importedLibrary.location,
|
| - original.importedLibrary.location,
|
| - reason: '$desc importedLibrary location');
|
| - expect(resynthesized.prefixOffset, original.prefixOffset,
|
| - reason: '$desc prefixOffset');
|
| - if (original.prefix == null) {
|
| - expect(resynthesized.prefix, isNull, reason: '$desc prefix');
|
| - } else {
|
| - comparePrefixElements(
|
| - resynthesized.prefix, original.prefix, original.prefix.name);
|
| - }
|
| - expect(resynthesized.combinators.length, original.combinators.length,
|
| - reason: '$desc combinators');
|
| - for (int i = 0; i < resynthesized.combinators.length; i++) {
|
| - compareNamespaceCombinators(
|
| - resynthesized.combinators[i], original.combinators[i]);
|
| - }
|
| - }
|
| -
|
| - void compareLabelElements(
|
| - LabelElementImpl resynthesized, LabelElementImpl original, String desc) {
|
| - expect(resynthesized.isOnSwitchMember, original.isOnSwitchMember,
|
| - reason: desc);
|
| - expect(resynthesized.isOnSwitchStatement, original.isOnSwitchStatement,
|
| - reason: desc);
|
| - compareElements(resynthesized, original, desc);
|
| - }
|
| -
|
| - void compareLocalElementsOfExecutable(ExecutableElement resynthesized,
|
| - ExecutableElement original, String desc) {
|
| - if (original is! Member) {
|
| - List<FunctionElement> rFunctions = resynthesized.functions;
|
| - List<FunctionElement> oFunctions = original.functions;
|
| - expect(rFunctions, hasLength(oFunctions.length));
|
| - for (int i = 0; i < oFunctions.length; i++) {
|
| - compareFunctionElements(rFunctions[i], oFunctions[i],
|
| - '$desc local function ${oFunctions[i].name}');
|
| - }
|
| - }
|
| - if (original is! Member) {
|
| - List<LabelElement> rLabels = resynthesized.labels;
|
| - List<LabelElement> oLabels = original.labels;
|
| - expect(rLabels, hasLength(oLabels.length));
|
| - for (int i = 0; i < oLabels.length; i++) {
|
| - compareLabelElements(
|
| - rLabels[i], oLabels[i], '$desc label ${oLabels[i].name}');
|
| - }
|
| - }
|
| - if (original is! Member) {
|
| - List<LocalVariableElement> rVariables = resynthesized.localVariables;
|
| - List<LocalVariableElement> oVariables = original.localVariables;
|
| - expect(rVariables, hasLength(oVariables.length));
|
| - for (int i = 0; i < oVariables.length; i++) {
|
| - compareVariableElements(rVariables[i], oVariables[i],
|
| - '$desc local variable ${oVariables[i].name}');
|
| - }
|
| - }
|
| - }
|
| -
|
| - void compareMetadata(List<ElementAnnotation> resynthesized,
|
| - List<ElementAnnotation> original, String desc) {
|
| - expect(resynthesized, hasLength(original.length), reason: desc);
|
| - for (int i = 0; i < original.length; i++) {
|
| - compareElementAnnotations(
|
| - resynthesized[i], original[i], '$desc annotation $i');
|
| - }
|
| - }
|
| -
|
| - void compareMethodElements(MethodElementImpl resynthesized,
|
| - MethodElementImpl original, String desc) {
|
| - // TODO(paulberry): do we need to deal with
|
| - // MultiplyInheritedMethodElementImpl?
|
| - compareExecutableElements(resynthesized, original, desc);
|
| - }
|
| -
|
| - void compareNamespaceCombinators(
|
| - NamespaceCombinator resynthesized, NamespaceCombinator original) {
|
| - if (original is ShowElementCombinatorImpl &&
|
| - resynthesized is ShowElementCombinatorImpl) {
|
| - expect(resynthesized.shownNames, original.shownNames,
|
| - reason: 'shownNames');
|
| - expect(resynthesized.offset, original.offset, reason: 'offset');
|
| - expect(resynthesized.end, original.end, reason: 'end');
|
| - } else if (original is HideElementCombinatorImpl &&
|
| - resynthesized is HideElementCombinatorImpl) {
|
| - expect(resynthesized.hiddenNames, original.hiddenNames,
|
| - reason: 'hiddenNames');
|
| - } else if (resynthesized.runtimeType != original.runtimeType) {
|
| - fail(
|
| - 'Type mismatch: expected ${original.runtimeType}, got ${resynthesized.runtimeType}');
|
| - } else {
|
| - fail('Unimplemented comparison for ${original.runtimeType}');
|
| - }
|
| - }
|
| -
|
| - void compareNamespaces(
|
| - Namespace resynthesized, Namespace original, String desc) {
|
| - Map<String, Element> resynthesizedMap = resynthesized.definedNames;
|
| - Map<String, Element> originalMap = original.definedNames;
|
| - expect(resynthesizedMap.keys.toSet(), originalMap.keys.toSet(),
|
| - reason: desc);
|
| - for (String key in originalMap.keys) {
|
| - Element resynthesizedElement = resynthesizedMap[key];
|
| - Element originalElement = originalMap[key];
|
| - compareElements(resynthesizedElement, originalElement, key);
|
| - }
|
| - }
|
| -
|
| - void compareParameterElementLists(
|
| - List<ParameterElement> resynthesizedParameters,
|
| - List<ParameterElement> originalParameters,
|
| - String desc) {
|
| - expect(resynthesizedParameters.length, originalParameters.length);
|
| - for (int i = 0; i < resynthesizedParameters.length; i++) {
|
| - compareParameterElements(
|
| - resynthesizedParameters[i],
|
| - originalParameters[i],
|
| - '$desc parameter ${originalParameters[i].name}');
|
| - }
|
| - }
|
| -
|
| - void compareParameterElements(
|
| - ParameterElement resynthesized, ParameterElement original, String desc) {
|
| - compareVariableElements(resynthesized, original, desc);
|
| - compareParameterElementLists(
|
| - resynthesized.parameters, original.parameters, desc);
|
| - expect(resynthesized.parameterKind, original.parameterKind, reason: desc);
|
| - expect(resynthesized.isInitializingFormal, original.isInitializingFormal,
|
| - reason: desc);
|
| - expect(resynthesized is FieldFormalParameterElementImpl,
|
| - original is FieldFormalParameterElementImpl);
|
| - if (resynthesized is FieldFormalParameterElementImpl &&
|
| - original is FieldFormalParameterElementImpl) {
|
| - if (original.field == null) {
|
| - expect(resynthesized.field, isNull, reason: '$desc field');
|
| - } else {
|
| - expect(resynthesized.field, isNotNull, reason: '$desc field');
|
| - compareFieldElements(
|
| - resynthesized.field, original.field, '$desc field');
|
| - }
|
| - }
|
| - expect(resynthesized.defaultValueCode, original.defaultValueCode,
|
| - reason: desc);
|
| - ParameterElementImpl resynthesizedActual =
|
| - getActualElement(resynthesized, desc);
|
| - ParameterElementImpl originalActual = getActualElement(original, desc);
|
| - compareFunctionElements(
|
| - resynthesizedActual.initializer, originalActual.initializer, desc);
|
| - }
|
| -
|
| - void comparePrefixElements(PrefixElementImpl resynthesized,
|
| - PrefixElementImpl original, String desc) {
|
| - compareElements(resynthesized, original, desc);
|
| - }
|
| -
|
| - void comparePropertyAccessorElements(
|
| - PropertyAccessorElementImpl resynthesized,
|
| - PropertyAccessorElementImpl original,
|
| - String desc) {
|
| - // TODO(paulberry): do I need to worry about
|
| - // MultiplyInheritedPropertyAccessorElementImpl?
|
| - compareExecutableElements(resynthesized, original, desc);
|
| - expect(resynthesized.variable, isNotNull);
|
| - expect(resynthesized.variable.location, original.variable.location);
|
| - }
|
| -
|
| - void comparePropertyInducingElements(
|
| - PropertyInducingElementImpl resynthesized,
|
| - PropertyInducingElementImpl original,
|
| - String desc) {
|
| - compareVariableElements(resynthesized, original, desc);
|
| - if (checkPropagatedTypes) {
|
| - compareTypes(resynthesized.propagatedType, original.propagatedType, desc);
|
| - }
|
| - if (original.getter == null) {
|
| - expect(resynthesized.getter, isNull);
|
| - } else {
|
| - expect(resynthesized.getter, isNotNull);
|
| - expect(resynthesized.getter.location, original.getter.location);
|
| - }
|
| - if (original.setter == null) {
|
| - expect(resynthesized.setter, isNull);
|
| - } else {
|
| - expect(resynthesized.setter, isNotNull);
|
| - expect(resynthesized.setter.location, original.setter.location);
|
| - }
|
| - }
|
| -
|
| - void compareTopLevelVariableElements(
|
| - TopLevelVariableElementImpl resynthesized,
|
| - TopLevelVariableElementImpl original,
|
| - String desc) {
|
| - comparePropertyInducingElements(resynthesized, original, desc);
|
| - }
|
| -
|
| - void compareTypeImpls(
|
| - TypeImpl resynthesized, TypeImpl original, String desc) {
|
| - expect(resynthesized.element.location, original.element.location,
|
| - reason: desc);
|
| - expect(resynthesized.name, original.name, reason: desc);
|
| - }
|
| -
|
| - void compareTypeParameterElements(TypeParameterElementImpl resynthesized,
|
| - TypeParameterElementImpl original, String desc) {
|
| - compareElements(resynthesized, original, desc);
|
| - compareTypes(resynthesized.type, original.type, desc);
|
| - compareTypes(resynthesized.bound, original.bound, '$desc bound');
|
| - }
|
| -
|
| - void compareTypes(DartType resynthesized, DartType original, String desc) {
|
| - if (original == null) {
|
| - expect(resynthesized, isNull, reason: desc);
|
| - } else if (resynthesized is InterfaceTypeImpl &&
|
| - original is InterfaceTypeImpl) {
|
| - compareTypeImpls(resynthesized, original, desc);
|
| - expect(resynthesized.typeArguments.length, original.typeArguments.length);
|
| - for (int i = 0; i < resynthesized.typeArguments.length; i++) {
|
| - compareTypes(resynthesized.typeArguments[i], original.typeArguments[i],
|
| - '$desc type argument ${original.typeArguments[i].name}');
|
| - }
|
| - } else if (resynthesized is TypeParameterTypeImpl &&
|
| - original is TypeParameterTypeImpl) {
|
| - compareTypeImpls(resynthesized, original, desc);
|
| - } else if (resynthesized is DynamicTypeImpl &&
|
| - original is DynamicTypeImpl) {
|
| - expect(resynthesized, same(original));
|
| - } else if (resynthesized is UndefinedTypeImpl &&
|
| - original is UndefinedTypeImpl) {
|
| - expect(resynthesized, same(original));
|
| - } else if (resynthesized is FunctionTypeImpl &&
|
| - original is FunctionTypeImpl) {
|
| - compareTypeImpls(resynthesized, original, desc);
|
| - expect(resynthesized.isInstantiated, original.isInstantiated,
|
| - reason: desc);
|
| - if (original.element.isSynthetic &&
|
| - original.element is FunctionTypeAliasElementImpl &&
|
| - resynthesized.element is FunctionTypeAliasElementImpl) {
|
| - compareFunctionTypeAliasElements(
|
| - resynthesized.element, original.element, desc);
|
| - }
|
| - if (original.element.enclosingElement == null &&
|
| - original.element is FunctionElement) {
|
| - expect(resynthesized.element, new isInstanceOf<FunctionElement>());
|
| - expect(resynthesized.element.enclosingElement, isNull, reason: desc);
|
| - compareFunctionElements(
|
| - resynthesized.element, original.element, '$desc element',
|
| - shallow: true);
|
| - expect(resynthesized.element.type, same(resynthesized));
|
| - }
|
| - expect(resynthesized.typeArguments.length, original.typeArguments.length,
|
| - reason: '$desc typeArguments.length');
|
| - for (int i = 0; i < resynthesized.typeArguments.length; i++) {
|
| - if (resynthesized.typeArguments[i].isDynamic &&
|
| - original.typeArguments[i] is TypeParameterType) {
|
| - // It's ok for type arguments to get converted to `dynamic` if they
|
| - // are not used.
|
| - expect(
|
| - isTypeParameterUsed(
|
| - original.typeArguments[i], original.element.type),
|
| - isFalse);
|
| - } else {
|
| - compareTypes(
|
| - resynthesized.typeArguments[i],
|
| - original.typeArguments[i],
|
| - '$desc type argument ${original.typeArguments[i].name}');
|
| - }
|
| - }
|
| - if (original.typeParameters == null) {
|
| - expect(resynthesized.typeParameters, isNull, reason: desc);
|
| - } else {
|
| - expect(resynthesized.typeParameters, isNotNull, reason: desc);
|
| - expect(
|
| - resynthesized.typeParameters.length, original.typeParameters.length,
|
| - reason: desc);
|
| - for (int i = 0; i < resynthesized.typeParameters.length; i++) {
|
| - compareTypeParameterElements(resynthesized.typeParameters[i],
|
| - original.typeParameters[i], '$desc type parameter $i');
|
| - }
|
| - }
|
| - expect(resynthesized.typeFormals.length, original.typeFormals.length,
|
| - reason: desc);
|
| - for (int i = 0; i < resynthesized.typeFormals.length; i++) {
|
| - compareTypeParameterElements(resynthesized.typeFormals[i],
|
| - original.typeFormals[i], '$desc bound type parameter $i');
|
| - }
|
| - } else if (resynthesized is VoidTypeImpl && original is VoidTypeImpl) {
|
| - expect(resynthesized, same(original));
|
| - } else if (resynthesized is DynamicTypeImpl &&
|
| - original is UndefinedTypeImpl) {
|
| - // TODO(scheglov) In the strong mode constant variable like
|
| - // `var V = new Unresolved()` gets `UndefinedTypeImpl`, and it gets
|
| - // `DynamicTypeImpl` in the spec mode.
|
| - } else if (resynthesized is BottomTypeImpl && original is BottomTypeImpl) {
|
| - expect(resynthesized, same(original));
|
| - } else if (resynthesized.runtimeType != original.runtimeType) {
|
| - fail('Type mismatch: expected ${original.runtimeType},'
|
| - ' got ${resynthesized.runtimeType} ($desc)');
|
| - } else {
|
| - fail('Unimplemented comparison for ${original.runtimeType}');
|
| - }
|
| - }
|
| -
|
| - void compareUriReferencedElements(UriReferencedElementImpl resynthesized,
|
| - UriReferencedElementImpl original, String desc) {
|
| - compareElements(resynthesized, original, desc);
|
| - expect(resynthesized.uri, original.uri, reason: '$desc uri');
|
| - expect(resynthesized.uriOffset, original.uriOffset,
|
| - reason: '$desc uri uriOffset');
|
| - expect(resynthesized.uriEnd, original.uriEnd, reason: '$desc uriEnd');
|
| - }
|
| -
|
| - void compareVariableElements(
|
| - VariableElement resynthesized, VariableElement original, String desc) {
|
| - compareElements(resynthesized, original, desc);
|
| - compareTypes(resynthesized.type, original.type, desc);
|
| - VariableElementImpl resynthesizedActual =
|
| - getActualElement(resynthesized, desc);
|
| - VariableElementImpl originalActual = getActualElement(original, desc);
|
| - compareFunctionElements(resynthesizedActual.initializer,
|
| - originalActual.initializer, '$desc initializer');
|
| - if (originalActual is ConstVariableElement) {
|
| - Element oEnclosing = original.enclosingElement;
|
| - if (oEnclosing is ClassElement && oEnclosing.isEnum) {
|
| - compareConstValues(
|
| - resynthesized.constantValue, original.constantValue, desc);
|
| - } else {
|
| - Expression initializer = resynthesizedActual.constantInitializer;
|
| - if (variablesWithNotConstInitializers.contains(resynthesized.name)) {
|
| - _assertUnresolvedIdentifier(initializer, desc);
|
| - } else {
|
| - compareConstAsts(initializer, originalActual.constantInitializer,
|
| - '$desc initializer');
|
| - }
|
| - }
|
| - }
|
| - checkPossibleMember(resynthesized, original, desc);
|
| - checkPossibleLocalElements(resynthesized, original);
|
| - }
|
| -
|
| - DartSdk createDartSdk() => AbstractContextTest.SHARED_MOCK_SDK;
|
| -
|
| - /**
|
| - * Determine the analysis options that should be used for this test.
|
| - */
|
| - AnalysisOptionsImpl createOptions() =>
|
| - new AnalysisOptionsImpl()..enableGenericMethods = true;
|
| -
|
| - /**
|
| - * Serialize the given [library] into a summary. Then create a
|
| - * [TestSummaryResynthesizer] which can deserialize it, along with any
|
| - * references it makes to `dart:core`.
|
| - *
|
| - * Errors will lead to a test failure unless [allowErrors] is `true`.
|
| - */
|
| - TestSummaryResynthesizer encodeLibrary(LibraryElementImpl library,
|
| - {bool allowErrors: false, bool dumpSummaries: false}) {
|
| - if (!allowErrors) {
|
| - assertNoErrors(library.source);
|
| - }
|
| - addLibrary('dart:core');
|
| - addLibrary('dart:async');
|
| - addLibrary('dart:math');
|
| - return encodeLibraryElement(library, dumpSummaries: dumpSummaries);
|
| - }
|
| -
|
| - /**
|
| - * Convert the library element [library] into a summary, and then create a
|
| - * [TestSummaryResynthesizer] which can deserialize it.
|
| - *
|
| - * Caller is responsible for checking the library for errors, and adding any
|
| - * dependent libraries using [addLibrary].
|
| - */
|
| - TestSummaryResynthesizer encodeLibraryElement(LibraryElementImpl library,
|
| - {bool dumpSummaries: false}) {
|
| - Map<String, UnlinkedUnit> unlinkedSummaries = <String, UnlinkedUnit>{};
|
| - LinkedLibrary getLinkedSummaryFor(LibraryElement lib) {
|
| - LibrarySerializationResult serialized = serializeLibrary(
|
| - lib, context.typeProvider, context.analysisOptions.strongMode);
|
| - for (int i = 0; i < serialized.unlinkedUnits.length; i++) {
|
| - unlinkedSummaries[serialized.unitUris[i]] =
|
| - new UnlinkedUnit.fromBuffer(serialized.unlinkedUnits[i].toBuffer());
|
| - }
|
| - return new LinkedLibrary.fromBuffer(serialized.linked.toBuffer());
|
| - }
|
| -
|
| - Map<String, LinkedLibrary> linkedSummaries = <String, LinkedLibrary>{
|
| - library.source.uri.toString(): getLinkedSummaryFor(library)
|
| - };
|
| - for (Source source in otherLibrarySources) {
|
| - LibraryElement original = context.computeLibraryElement(source);
|
| - String uri = source.uri.toString();
|
| - linkedSummaries[uri] = getLinkedSummaryFor(original);
|
| - }
|
| - if (dumpSummaries) {
|
| - unlinkedSummaries.forEach((String path, UnlinkedUnit unit) {
|
| - print('Unlinked $path: ${JSON.encode(canonicalize(unit))}');
|
| - });
|
| - linkedSummaries.forEach((String path, LinkedLibrary lib) {
|
| - print('Linked $path: ${JSON.encode(canonicalize(lib))}');
|
| - });
|
| - }
|
| - return new TestSummaryResynthesizer(
|
| - null, context, unlinkedSummaries, linkedSummaries, allowMissingFiles);
|
| - }
|
| -
|
| - ElementImpl getActualElement(Element element, String desc) {
|
| - if (element == null) {
|
| - return null;
|
| - } else if (element is ElementImpl) {
|
| - return element;
|
| - } else if (element is ElementHandle) {
|
| - Element actualElement = element.actualElement;
|
| - // A handle should never point to a member, because if it did, then
|
| - // "is Member" checks on the handle would produce the wrong result.
|
| - expect(actualElement, isNot(new isInstanceOf<Member>()), reason: desc);
|
| - return getActualElement(actualElement, desc);
|
| - } else if (element is Member) {
|
| - return getActualElement(element.baseElement, desc);
|
| - } else {
|
| - fail('Unexpected type for resynthesized ($desc):'
|
| - ' ${element.runtimeType}');
|
| - return null;
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Determine if [type] makes use of the given [typeParameter].
|
| - */
|
| - bool isTypeParameterUsed(TypeParameterType typeParameter, DartType type) {
|
| - if (type is FunctionType) {
|
| - return isTypeParameterUsed(typeParameter, type.returnType) ||
|
| - type.parameters.any((ParameterElement e) =>
|
| - isTypeParameterUsed(typeParameter, e.type));
|
| - } else if (type is InterfaceType) {
|
| - return type.typeArguments
|
| - .any((DartType t) => isTypeParameterUsed(typeParameter, t));
|
| - } else if (type is TypeParameterType) {
|
| - return type == typeParameter;
|
| - } else {
|
| - expect(type.isDynamic || type.isVoid, isTrue);
|
| - return false;
|
| - }
|
| - }
|
| -
|
| - @override
|
| - void setUp() {
|
| - super.setUp();
|
| - prepareAnalysisContext(createOptions());
|
| - }
|
| -
|
| - void _assertUnresolvedIdentifier(Expression initializer, String desc) {
|
| - expect(initializer, new isInstanceOf<SimpleIdentifier>(), reason: desc);
|
| - SimpleIdentifier identifier = initializer;
|
| - expect(identifier.staticElement, isNull, reason: desc);
|
| - }
|
| -
|
| - List<PropertyAccessorElement> _getSortedPropertyAccessors(
|
| - ClassElement classElement) {
|
| - List<PropertyAccessorElement> accessors = classElement.accessors.toList();
|
| - accessors.sort((a, b) => a.displayName.compareTo(b.displayName));
|
| - return accessors;
|
| - }
|
| -
|
| - bool _hasModifier(Element element, Modifier modifier) {
|
| - if (modifier == Modifier.ABSTRACT) {
|
| - if (element is ClassElement) {
|
| - return element.isAbstract;
|
| - }
|
| - if (element is ExecutableElement) {
|
| - return element.isAbstract;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.ASYNCHRONOUS) {
|
| - if (element is ExecutableElement) {
|
| - return element.isAsynchronous;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.CONST) {
|
| - if (element is VariableElement) {
|
| - return element.isConst;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.DEFERRED) {
|
| - if (element is ImportElement) {
|
| - return element.isDeferred;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.ENUM) {
|
| - if (element is ClassElement) {
|
| - return element.isEnum;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.EXTERNAL) {
|
| - if (element is ExecutableElement) {
|
| - return element.isExternal;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.FACTORY) {
|
| - if (element is ConstructorElement) {
|
| - return element.isFactory;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.FINAL) {
|
| - if (element is VariableElement) {
|
| - return element.isFinal;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.GENERATOR) {
|
| - if (element is ExecutableElement) {
|
| - return element.isGenerator;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.GETTER) {
|
| - if (element is PropertyAccessorElement) {
|
| - return element.isGetter;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.HAS_EXT_URI) {
|
| - if (element is LibraryElement) {
|
| - return element.hasExtUri;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.IMPLICIT_TYPE) {
|
| - if (element is ExecutableElement) {
|
| - return element.hasImplicitReturnType;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.MIXIN_APPLICATION) {
|
| - if (element is ClassElement) {
|
| - return element.isMixinApplication;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.REFERENCES_SUPER) {
|
| - if (element is ClassElement) {
|
| - return element.hasReferenceToSuper;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.SETTER) {
|
| - if (element is PropertyAccessorElement) {
|
| - return element.isSetter;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.STATIC) {
|
| - if (element is ExecutableElement) {
|
| - return element.isStatic;
|
| - }
|
| - return false;
|
| - } else if (modifier == Modifier.SYNTHETIC) {
|
| - return element.isSynthetic;
|
| - }
|
| - throw new UnimplementedError(
|
| - 'Modifier $modifier for ${element?.runtimeType}');
|
| - }
|
| -}
|
| -
|
| -@reflectiveTest
|
| -class ResynthesizeElementTest extends ResynthesizeTest {
|
| - @override
|
| - LibraryElementImpl checkLibrary(String text,
|
| - {bool allowErrors: false, bool dumpSummaries: false}) {
|
| - Source source = addTestSource(text);
|
| - LibraryElementImpl original = context.computeLibraryElement(source);
|
| - LibraryElementImpl resynthesized = resynthesizeLibraryElement(
|
| - encodeLibrary(original,
|
| - allowErrors: allowErrors, dumpSummaries: dumpSummaries),
|
| - source.uri.toString(),
|
| - original);
|
| - checkLibraryElements(original, resynthesized);
|
| - return resynthesized;
|
| - }
|
| -
|
| - @override
|
| - SummaryResynthesizer encodeDecodeLibrarySource(Source librarySource) {
|
| - LibraryElement libraryElement =
|
| - context.computeLibraryElement(librarySource);
|
| - return encodeLibrary(libraryElement);
|
| - }
|
| -
|
| - /**
|
| - * Serialize the given [library] into a summary. Then create a
|
| - * [TestSummaryResynthesizer] which can deserialize it, along with any
|
| - * references it makes to `dart:core`.
|
| - *
|
| - * Errors will lead to a test failure unless [allowErrors] is `true`.
|
| - */
|
| - TestSummaryResynthesizer encodeLibrary(LibraryElementImpl library,
|
| - {bool allowErrors: false, bool dumpSummaries: false}) {
|
| - if (!allowErrors) {
|
| - assertNoErrors(library.source);
|
| - }
|
| - addLibrary('dart:core');
|
| - addLibrary('dart:async');
|
| - addLibrary('dart:math');
|
| - return encodeLibraryElement(library, dumpSummaries: dumpSummaries);
|
| - }
|
| -
|
| - /**
|
| - * Convert the library element [library] into a summary, and then create a
|
| - * [TestSummaryResynthesizer] which can deserialize it.
|
| - *
|
| - * Caller is responsible for checking the library for errors, and adding any
|
| - * dependent libraries using [addLibrary].
|
| - */
|
| - TestSummaryResynthesizer encodeLibraryElement(LibraryElementImpl library,
|
| - {bool dumpSummaries: false}) {
|
| - Map<String, UnlinkedUnit> unlinkedSummaries = <String, UnlinkedUnit>{};
|
| - LinkedLibrary getLinkedSummaryFor(LibraryElement lib) {
|
| - LibrarySerializationResult serialized = serializeLibrary(
|
| - lib, context.typeProvider, context.analysisOptions.strongMode);
|
| - for (int i = 0; i < serialized.unlinkedUnits.length; i++) {
|
| - unlinkedSummaries[serialized.unitUris[i]] =
|
| - new UnlinkedUnit.fromBuffer(serialized.unlinkedUnits[i].toBuffer());
|
| - }
|
| - return new LinkedLibrary.fromBuffer(serialized.linked.toBuffer());
|
| - }
|
| -
|
| - Map<String, LinkedLibrary> linkedSummaries = <String, LinkedLibrary>{
|
| - library.source.uri.toString(): getLinkedSummaryFor(library)
|
| - };
|
| - for (Source source in otherLibrarySources) {
|
| - LibraryElement original = context.computeLibraryElement(source);
|
| - String uri = source.uri.toString();
|
| - linkedSummaries[uri] = getLinkedSummaryFor(original);
|
| - }
|
| - if (dumpSummaries) {
|
| - unlinkedSummaries.forEach((String path, UnlinkedUnit unit) {
|
| - print('Unlinked $path: ${JSON.encode(canonicalize(unit))}');
|
| - });
|
| - linkedSummaries.forEach((String path, LinkedLibrary lib) {
|
| - print('Linked $path: ${JSON.encode(canonicalize(lib))}');
|
| - });
|
| - }
|
| - return new TestSummaryResynthesizer(
|
| - null, context, unlinkedSummaries, linkedSummaries, allowMissingFiles);
|
| - }
|
| -
|
| - /**
|
| - * Resynthesize the library element associated with [uri] using
|
| - * [resynthesizer], and verify that it only had to consult one summary in
|
| - * order to do so. [original] is consulted merely to verify that no
|
| - * unnecessary resynthesis work was performed.
|
| - */
|
| - LibraryElementImpl resynthesizeLibraryElement(
|
| - TestSummaryResynthesizer resynthesizer,
|
| - String uri,
|
| - LibraryElement original) {
|
| - LibraryElementImpl resynthesized = resynthesizer.getLibraryElement(uri);
|
| - checkMinimalResynthesisWork(resynthesizer, original);
|
| - return resynthesized;
|
| - }
|
| -
|
| - test_core() {
|
| - addLibrary('dart:async');
|
| - addLibrary('dart:math');
|
| - String uri = 'dart:core';
|
| - LibraryElementImpl original =
|
| - context.computeLibraryElement(context.sourceFactory.forUri(uri));
|
| - LibraryElementImpl resynthesized = resynthesizeLibraryElement(
|
| - encodeLibraryElement(original), uri, original);
|
| - checkLibraryElements(original, resynthesized);
|
| - }
|
| -}
|
| -
|
| -@reflectiveTest
|
| -abstract class ResynthesizeTest extends AbstractResynthesizeTest {
|
| - LibraryElementImpl checkLibrary(String text,
|
| - {bool allowErrors: false, bool dumpSummaries: false});
|
| -
|
| - /**
|
| - * Return a [SummaryResynthesizer] to resynthesize the library with the
|
| - * given [librarySource].
|
| - */
|
| - SummaryResynthesizer encodeDecodeLibrarySource(Source librarySource);
|
| -
|
| - fail_library_hasExtUri() {
|
| - checkLibrary('import "dart-ext:doesNotExist.dart";');
|
| - }
|
| -
|
| - test_class_abstract() {
|
| - checkLibrary('abstract class C {}');
|
| - }
|
| -
|
| - test_class_alias() {
|
| - checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
|
| - }
|
| -
|
| - test_class_alias_abstract() {
|
| - checkLibrary('abstract class C = D with E; class D {} class E {}');
|
| - }
|
| -
|
| - test_class_alias_documented() {
|
| - checkLibrary('''
|
| -// Extra comment so doc comment offset != 0
|
| -/**
|
| - * Docs
|
| - */
|
| -class C = D with E;
|
| -
|
| -class D {}
|
| -class E {}''');
|
| - }
|
| -
|
| - test_class_alias_with_forwarding_constructors() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - '''
|
| -class Base {
|
| - Base._priv();
|
| - Base();
|
| - Base.noArgs();
|
| - Base.requiredArg(x);
|
| - Base.positionalArg([x]);
|
| - Base.namedArg({x});
|
| - factory Base.fact() => null;
|
| - factory Base.fact2() = Base.noArgs;
|
| -}
|
| -''');
|
| - checkLibrary('''
|
| -import "a.dart";
|
| -class M {}
|
| -class MixinApp = Base with M;
|
| -''');
|
| - }
|
| -
|
| - test_class_alias_with_forwarding_constructors_type_substitution() {
|
| - checkLibrary('''
|
| -class Base<T> {
|
| - Base.ctor(T t, List<T> l);
|
| -}
|
| -class M {}
|
| -class MixinApp = Base with M;
|
| -''');
|
| - }
|
| -
|
| - test_class_alias_with_forwarding_constructors_type_substitution_complex() {
|
| - checkLibrary('''
|
| -class Base<T> {
|
| - Base.ctor(T t, List<T> l);
|
| -}
|
| -class M {}
|
| -class MixinApp<U> = Base<List<U>> with M;
|
| -''');
|
| - }
|
| -
|
| - test_class_alias_with_mixin_members() {
|
| - checkLibrary('''
|
| -class C = D with E;
|
| -class D {}
|
| -class E {
|
| - int get a => null;
|
| - void set b(int i) {}
|
| - void f() {}
|
| - int x;
|
| -}''');
|
| - }
|
| -
|
| - test_class_constructor_const() {
|
| - checkLibrary('class C { const C(); }');
|
| - }
|
| -
|
| - test_class_constructor_const_external() {
|
| - checkLibrary('class C { external const C(); }');
|
| - }
|
| -
|
| - test_class_constructor_explicit_named() {
|
| - checkLibrary('class C { C.foo(); }');
|
| - }
|
| -
|
| - test_class_constructor_explicit_type_params() {
|
| - checkLibrary('class C<T, U> { C(); }');
|
| - }
|
| -
|
| - test_class_constructor_explicit_unnamed() {
|
| - checkLibrary('class C { C(); }');
|
| - }
|
| -
|
| - test_class_constructor_external() {
|
| - checkLibrary('class C { external C(); }');
|
| - }
|
| -
|
| - test_class_constructor_factory() {
|
| - checkLibrary('class C { factory C() => null; }');
|
| - }
|
| -
|
| - test_class_constructor_field_formal_dynamic_dynamic() {
|
| - checkLibrary('class C { dynamic x; C(dynamic this.x); }');
|
| - }
|
| -
|
| - test_class_constructor_field_formal_dynamic_typed() {
|
| - checkLibrary('class C { dynamic x; C(int this.x); }');
|
| - }
|
| -
|
| - test_class_constructor_field_formal_dynamic_untyped() {
|
| - checkLibrary('class C { dynamic x; C(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);
|
| - }
|
| -
|
| - 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);
|
| - }
|
| -
|
| - test_class_constructor_field_formal_typed_dynamic() {
|
| - checkLibrary('class C { num x; C(dynamic this.x); }', allowErrors: true);
|
| - }
|
| -
|
| - test_class_constructor_field_formal_typed_typed() {
|
| - checkLibrary('class C { num x; C(int this.x); }');
|
| - }
|
| -
|
| - test_class_constructor_field_formal_typed_untyped() {
|
| - checkLibrary('class C { num x; C(this.x); }');
|
| - }
|
| -
|
| - test_class_constructor_field_formal_untyped_dynamic() {
|
| - checkLibrary('class C { var x; C(dynamic this.x); }');
|
| - }
|
| -
|
| - test_class_constructor_field_formal_untyped_typed() {
|
| - checkLibrary('class C { var x; C(int this.x); }');
|
| - }
|
| -
|
| - test_class_constructor_field_formal_untyped_untyped() {
|
| - checkLibrary('class C { var x; C(this.x); }');
|
| - }
|
| -
|
| - test_class_constructor_fieldFormal_named_noDefault() {
|
| - checkLibrary('class C { int x; C({this.x}); }');
|
| - }
|
| -
|
| - test_class_constructor_fieldFormal_named_withDefault() {
|
| - checkLibrary('class C { int x; C({this.x: 42}); }');
|
| - }
|
| -
|
| - test_class_constructor_fieldFormal_optional_noDefault() {
|
| - checkLibrary('class C { int x; C([this.x]); }');
|
| - }
|
| -
|
| - test_class_constructor_fieldFormal_optional_withDefault() {
|
| - checkLibrary('class C { int x; C([this.x = 42]); }');
|
| - }
|
| -
|
| - test_class_constructor_implicit() {
|
| - checkLibrary('class C {}');
|
| - }
|
| -
|
| - test_class_constructor_implicit_type_params() {
|
| - checkLibrary('class C<T, U> {}');
|
| - }
|
| -
|
| - test_class_constructor_params() {
|
| - checkLibrary('class C { C(x, y); }');
|
| - }
|
| -
|
| - test_class_constructors() {
|
| - checkLibrary('class C { C.foo(); C.bar(); }');
|
| - }
|
| -
|
| - test_class_documented() {
|
| - checkLibrary('''
|
| -// Extra comment so doc comment offset != 0
|
| -/**
|
| - * Docs
|
| - */
|
| -class C {}''');
|
| - }
|
| -
|
| - test_class_documented_with_references() {
|
| - checkLibrary('''
|
| -/**
|
| - * 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 {}');
|
| - }
|
| -
|
| - test_class_field_const() {
|
| - checkLibrary('class C { static const int i = 0; }');
|
| - }
|
| -
|
| - test_class_field_implicit_type() {
|
| - checkLibrary('class C { var x; }');
|
| - }
|
| -
|
| - test_class_field_static() {
|
| - checkLibrary('class C { static int i; }');
|
| - }
|
| -
|
| - test_class_fields() {
|
| - checkLibrary('class C { int i; int j; }');
|
| - }
|
| -
|
| - test_class_getter_abstract() {
|
| - checkLibrary('abstract class C { int get x; }');
|
| - }
|
| -
|
| - test_class_getter_external() {
|
| - checkLibrary('class C { external int get x; }');
|
| - }
|
| -
|
| - test_class_getter_implicit_return_type() {
|
| - checkLibrary('class C { get x => null; }');
|
| - }
|
| -
|
| - test_class_getter_static() {
|
| - checkLibrary('class C { static int get x => null; }');
|
| - }
|
| -
|
| - test_class_getters() {
|
| - checkLibrary('class C { int get x => null; get y => null; }');
|
| - }
|
| -
|
| - test_class_implicitField_getterFirst() {
|
| - checkLibrary('class C { int get x => 0; void set x(int value) {} }');
|
| - }
|
| -
|
| - test_class_implicitField_setterFirst() {
|
| - checkLibrary('class C { void set x(int value) {} int get x => 0; }');
|
| - }
|
| -
|
| - test_class_interfaces() {
|
| - checkLibrary('class C implements D, E {} class D {} class E {}');
|
| - }
|
| -
|
| - test_class_interfaces_unresolved() {
|
| - checkLibrary('class C implements X, Y, Z {} class X {} class Z {}',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_class_method_abstract() {
|
| - checkLibrary('abstract class C { f(); }');
|
| - }
|
| -
|
| - test_class_method_external() {
|
| - checkLibrary('class C { external f(); }');
|
| - }
|
| -
|
| - test_class_method_params() {
|
| - checkLibrary('class C { f(x, y) {} }');
|
| - }
|
| -
|
| - test_class_method_static() {
|
| - checkLibrary('class C { static f() {} }');
|
| - }
|
| -
|
| - test_class_methods() {
|
| - checkLibrary('class C { f() {} g() {} }');
|
| - }
|
| -
|
| - test_class_mixins() {
|
| - checkLibrary('class C extends Object with D, E {} class D {} class E {}');
|
| - }
|
| -
|
| - test_class_mixins_unresolved() {
|
| - checkLibrary('class C extends Object with X, Y, Z; class X {} class Z {}',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_class_setter_abstract() {
|
| - checkLibrary('abstract class C { void set x(int value); }');
|
| - }
|
| -
|
| - test_class_setter_external() {
|
| - checkLibrary('class C { external void set x(int value); }');
|
| - }
|
| -
|
| - test_class_setter_implicit_param_type() {
|
| - checkLibrary('class C { void set x(value) {} }');
|
| - }
|
| -
|
| - test_class_setter_implicit_return_type() {
|
| - checkLibrary('class C { set x(int value) {} }');
|
| - }
|
| -
|
| - test_class_setter_static() {
|
| - checkLibrary('class C { static void set x(int value) {} }');
|
| - }
|
| -
|
| - test_class_setters() {
|
| - checkLibrary('class C { void set x(int value) {} set y(value) {} }');
|
| - }
|
| -
|
| - test_class_supertype() {
|
| - checkLibrary('class C extends D {} class D {}');
|
| - }
|
| -
|
| - test_class_supertype_unresolved() {
|
| - checkLibrary('class C extends D {}', allowErrors: true);
|
| - }
|
| -
|
| - test_class_type_parameters() {
|
| - checkLibrary('class C<T, U> {}');
|
| - }
|
| -
|
| - test_class_type_parameters_bound() {
|
| - checkLibrary('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> {}');
|
| - }
|
| -
|
| - test_class_type_parameters_f_bound_simple() {
|
| - checkLibrary('class C<T extends U, U> {}');
|
| - }
|
| -
|
| - test_classes() {
|
| - checkLibrary('class C {} class D {}');
|
| - }
|
| -
|
| - test_closure_executable_with_return_type_from_closure() {
|
| - checkLibrary('''
|
| -f() {
|
| - print(() {});
|
| - print(() => () => 0);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_const_invalid_field_const() {
|
| - variablesWithNotConstInitializers.add('f');
|
| - checkLibrary(
|
| - r'''
|
| -class C {
|
| - static const f = 1 + foo();
|
| -}
|
| -int foo() => 42;
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_invalid_field_final() {
|
| - variablesWithNotConstInitializers.add('f');
|
| - checkLibrary(
|
| - r'''
|
| -class C {
|
| - final f = 1 + foo();
|
| -}
|
| -int foo() => 42;
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_invalid_topLevel() {
|
| - variablesWithNotConstInitializers.add('v');
|
| - checkLibrary(
|
| - r'''
|
| -const v = 1 + foo();
|
| -int foo() => 42;
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_invokeConstructor_generic_named() {
|
| - checkLibrary(r'''
|
| -class C<K, V> {
|
| - const C.named(K k, V v);
|
| -}
|
| -const V = const C<int, String>.named(1, '222');
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_generic_named_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C<K, V> {
|
| - const C.named(K k, V v);
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const V = const C<int, String>.named(1, '222');
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_generic_named_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C<K, V> {
|
| - const C.named(K k, V v);
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const V = const p.C<int, String>.named(1, '222');
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_generic_noTypeArguments() {
|
| - checkLibrary(r'''
|
| -class C<K, V> {
|
| - const C();
|
| -}
|
| -const V = const C();
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_generic_unnamed() {
|
| - checkLibrary(r'''
|
| -class C<K, V> {
|
| - const C();
|
| -}
|
| -const V = const C<int, String>();
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_generic_unnamed_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C<K, V> {
|
| - const C();
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const V = const C<int, String>();
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_generic_unnamed_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C<K, V> {
|
| - const C();
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const V = const p.C<int, String>();
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_named() {
|
| - 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);
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_named_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| - const C.named();
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const V = const C.named();
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_named_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| - const C.named();
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const V = const p.C.named();
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_named_unresolved() {
|
| - checkLibrary(
|
| - r'''
|
| -class C {}
|
| -const V = const C.named();
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_invokeConstructor_named_unresolved2() {
|
| - checkLibrary(
|
| - r'''
|
| -const V = const C.named();
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_invokeConstructor_named_unresolved3() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| -}
|
| -''');
|
| - checkLibrary(
|
| - r'''
|
| -import 'a.dart' as p;
|
| -const V = const p.C.named();
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_invokeConstructor_named_unresolved4() {
|
| - addLibrarySource('/a.dart', '');
|
| - checkLibrary(
|
| - r'''
|
| -import 'a.dart' as p;
|
| -const V = const p.C.named();
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_invokeConstructor_named_unresolved5() {
|
| - checkLibrary(
|
| - r'''
|
| -const V = const p.C.named();
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_invokeConstructor_unnamed() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - const C();
|
| -}
|
| -const V = const C();
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_unnamed_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| - const C();
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const V = const C();
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_unnamed_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| - const C();
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const V = const p.C();
|
| -''');
|
| - }
|
| -
|
| - test_const_invokeConstructor_unnamed_unresolved() {
|
| - checkLibrary(
|
| - r'''
|
| -const V = const C();
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_invokeConstructor_unnamed_unresolved2() {
|
| - addLibrarySource('/a.dart', '');
|
| - checkLibrary(
|
| - r'''
|
| -import 'a.dart' as p;
|
| -const V = const p.C();
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_invokeConstructor_unnamed_unresolved3() {
|
| - checkLibrary(
|
| - r'''
|
| -const V = const p.C();
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_length_ofClassConstField() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - static const String F = '';
|
| -}
|
| -const int v = C.F.length;
|
| -''');
|
| - }
|
| -
|
| - test_const_length_ofClassConstField_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| - static const String F = '';
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const int v = C.F.length;
|
| -''');
|
| - }
|
| -
|
| - test_const_length_ofClassConstField_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| - static const String F = '';
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const int v = p.C.F.length;
|
| -''');
|
| - }
|
| -
|
| - test_const_length_ofStringLiteral() {
|
| - checkLibrary(r'''
|
| -const v = 'abc'.length;
|
| -''');
|
| - }
|
| -
|
| - test_const_length_ofTopLevelVariable() {
|
| - checkLibrary(r'''
|
| -const String S = 'abc';
|
| -const v = S.length;
|
| -''');
|
| - }
|
| -
|
| - test_const_length_ofTopLevelVariable_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -const String S = 'abc';
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const v = S.length;
|
| -''');
|
| - }
|
| -
|
| - test_const_length_ofTopLevelVariable_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -const String S = 'abc';
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const v = p.S.length;
|
| -''');
|
| - }
|
| -
|
| - test_const_length_staticMethod() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - static int length() => 42;
|
| -}
|
| -const v = C.length;
|
| -''');
|
| - }
|
| -
|
| - test_const_parameterDefaultValue_initializingFormal_functionTyped() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - final x;
|
| - const C({this.x: foo});
|
| -}
|
| -int foo() => 42;
|
| -''');
|
| - }
|
| -
|
| - test_const_parameterDefaultValue_initializingFormal_named() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - final x;
|
| - const C({this.x: 1 + 2});
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_const_parameterDefaultValue_initializingFormal_positional() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - final x;
|
| - const C([this.x = 1 + 2]);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_const_parameterDefaultValue_normal() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - const C.positional([p = 1 + 2]);
|
| - const C.named({p: 1 + 2});
|
| - void methodPositional([p = 1 + 2]) {}
|
| - void methodPositionalWithoutDefault([p]) {}
|
| - void methodNamed({p: 1 + 2}) {}
|
| - void methodNamedWithoutDefault({p}) {}
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_staticField() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - static const int F = 42;
|
| -}
|
| -const V = C.F;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_staticField_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| - static const int F = 42;
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const V = C.F;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_staticField_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| - static const int F = 42;
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const V = p.C.F;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_staticMethod() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - static int m(int a, String b) => 42;
|
| -}
|
| -const V = C.m;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_staticMethod_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| - static int m(int a, String b) => 42;
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const V = C.m;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_staticMethod_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {
|
| - static int m(int a, String b) => 42;
|
| -}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const V = p.C.m;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_topLevelFunction() {
|
| - checkLibrary(r'''
|
| -foo() {}
|
| -const V = foo;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_topLevelFunction_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -foo() {}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const V = foo;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_topLevelFunction_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -foo() {}
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const V = p.foo;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_topLevelVariable() {
|
| - checkLibrary(r'''
|
| -const A = 1;
|
| -const B = A + 2;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_topLevelVariable_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -const A = 1;
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const B = A + 2;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_topLevelVariable_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -const A = 1;
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const B = p.A + 2;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_type() {
|
| - checkLibrary(r'''
|
| -class C {}
|
| -class D<T> {}
|
| -enum E {a, b, c}
|
| -typedef F(int a, String b);
|
| -const vDynamic = dynamic;
|
| -const vNull = Null;
|
| -const vObject = Object;
|
| -const vClass = C;
|
| -const vGenericClass = D;
|
| -const vEnum = E;
|
| -const vFunctionTypeAlias = F;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_type_functionType() {
|
| - checkLibrary(r'''
|
| -typedef F();
|
| -class C {
|
| - final f = <F>[];
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_type_imported() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {}
|
| -enum E {a, b, c}
|
| -typedef F(int a, String b);
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const vClass = C;
|
| -const vEnum = E;
|
| -const vFunctionTypeAlias = F;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_type_imported_withPrefix() {
|
| - addLibrarySource(
|
| - '/a.dart',
|
| - r'''
|
| -class C {}
|
| -enum E {a, b, c}
|
| -typedef F(int a, String b);
|
| -''');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const vClass = p.C;
|
| -const vEnum = p.E;
|
| -const vFunctionTypeAlias = p.F;
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_type_typeParameter() {
|
| - checkLibrary(r'''
|
| -class C<T> {
|
| - final f = <T>[];
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_const_reference_unresolved_prefix0() {
|
| - checkLibrary(
|
| - r'''
|
| -const V = foo;
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_reference_unresolved_prefix1() {
|
| - checkLibrary(
|
| - r'''
|
| -class C {}
|
| -const v = C.foo;
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_reference_unresolved_prefix2() {
|
| - addLibrarySource(
|
| - '/foo.dart',
|
| - '''
|
| -class C {}
|
| -''');
|
| - checkLibrary(
|
| - r'''
|
| -import 'foo.dart' as p;
|
| -const v = p.C.foo;
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_const_topLevel_binary() {
|
| - checkLibrary(r'''
|
| -const vEqual = 1 == 2;
|
| -const vAnd = true && false;
|
| -const vOr = false || true;
|
| -const vBitXor = 1 ^ 2;
|
| -const vBitAnd = 1 & 2;
|
| -const vBitOr = 1 | 2;
|
| -const vBitShiftLeft = 1 << 2;
|
| -const vBitShiftRight = 1 >> 2;
|
| -const vAdd = 1 + 2;
|
| -const vSubtract = 1 - 2;
|
| -const vMiltiply = 1 * 2;
|
| -const vDivide = 1 / 2;
|
| -const vFloorDivide = 1 ~/ 2;
|
| -const vModulo = 1 % 2;
|
| -const vGreater = 1 > 2;
|
| -const vGreaterEqual = 1 >= 2;
|
| -const vLess = 1 < 2;
|
| -const vLessEqual = 1 <= 2;
|
| -''');
|
| - }
|
| -
|
| - test_const_topLevel_conditional() {
|
| - checkLibrary(r'''
|
| -const vConditional = (1 == 2) ? 11 : 22;
|
| -''');
|
| - }
|
| -
|
| - test_const_topLevel_identical() {
|
| - checkLibrary(r'''
|
| -const vIdentical = (1 == 2) ? 11 : 22;
|
| -''');
|
| - }
|
| -
|
| - test_const_topLevel_literal() {
|
| - checkLibrary(r'''
|
| -const vNull = null;
|
| -const vBoolFalse = false;
|
| -const vBoolTrue = true;
|
| -const vInt = 1;
|
| -const vIntLong = 0x9876543210987654321;
|
| -const vDouble = 2.3;
|
| -const vString = 'abc';
|
| -const vStringConcat = 'aaa' 'bbb';
|
| -const vStringInterpolation = 'aaa ${true} ${42} bbb';
|
| -const vSymbol = #aaa.bbb.ccc;
|
| -''');
|
| - }
|
| -
|
| - test_const_topLevel_prefix() {
|
| - checkLibrary(r'''
|
| -const vNotEqual = 1 != 2;
|
| -const vNot = !true;
|
| -const vNegate = -1;
|
| -const vComplement = ~1;
|
| -''');
|
| - }
|
| -
|
| - test_const_topLevel_typedList() {
|
| - checkLibrary(r'''
|
| -const vNull = const <Null>[];
|
| -const vDynamic = const <dynamic>[1, 2, 3];
|
| -const vInterfaceNoTypeParameters = const <int>[1, 2, 3];
|
| -const vInterfaceNoTypeArguments = const <List>[];
|
| -const vInterfaceWithTypeArguments = const <List<String>>[];
|
| -const vInterfaceWithTypeArguments2 = const <Map<int, List<String>>>[];
|
| -''');
|
| - }
|
| -
|
| - test_const_topLevel_typedList_imported() {
|
| - addLibrarySource('/a.dart', 'class C {}');
|
| - checkLibrary(r'''
|
| -import 'a.dart';
|
| -const v = const <C>[];
|
| -''');
|
| - }
|
| -
|
| - test_const_topLevel_typedList_importedWithPrefix() {
|
| - addLibrarySource('/a.dart', 'class C {}');
|
| - checkLibrary(r'''
|
| -import 'a.dart' as p;
|
| -const v = const <p.C>[];
|
| -''');
|
| - }
|
| -
|
| - test_const_topLevel_typedMap() {
|
| - checkLibrary(r'''
|
| -const vDynamic1 = const <dynamic, int>{};
|
| -const vDynamic2 = const <int, dynamic>{};
|
| -const vInterface = const <int, String>{};
|
| -const vInterfaceWithTypeArguments = const <int, List<String>>{};
|
| -''');
|
| - }
|
| -
|
| - test_const_topLevel_untypedList() {
|
| - checkLibrary(r'''
|
| -const v = const [1, 2, 3];
|
| -''');
|
| - }
|
| -
|
| - test_const_topLevel_untypedMap() {
|
| - checkLibrary(r'''
|
| -const v = const {0: 'aaa', 1: 'bbb', 2: 'ccc'};
|
| -''');
|
| - }
|
| -
|
| - test_constExpr_pushReference_field_simpleIdentifier() {
|
| - checkLibrary('''
|
| -class C {
|
| - static const a = b;
|
| - static const b = null;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constExpr_pushReference_staticMethod_simpleIdentifier() {
|
| - checkLibrary('''
|
| -class C {
|
| - static const a = m;
|
| - static m() {}
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_documented() {
|
| - checkLibrary('''
|
| -class C {
|
| - /**
|
| - * Docs
|
| - */
|
| - C();
|
| -}''');
|
| - }
|
| -
|
| - test_constructor_initializers_field() {
|
| - checkLibrary('''
|
| -class C {
|
| - final x;
|
| - const C() : x = 42;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_initializers_field_notConst() {
|
| - variablesWithNotConstInitializers.add('x');
|
| - checkLibrary(
|
| - '''
|
| -class C {
|
| - final x;
|
| - const A() : x = foo();
|
| -}
|
| -int foo() => 42;
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_constructor_initializers_field_withParameter() {
|
| - checkLibrary('''
|
| -class C {
|
| - final x;
|
| - const C(int p) : x = 1 + p;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_initializers_superInvocation_named() {
|
| - checkLibrary('''
|
| -class A {
|
| - const A.aaa(int p);
|
| -}
|
| -class C extends A {
|
| - const C() : super.aaa(42);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_initializers_superInvocation_namedExpression() {
|
| - checkLibrary('''
|
| -class A {
|
| - const A.aaa(a, {int b});
|
| -}
|
| -class C extends A {
|
| - const C() : super.aaa(1, b: 2);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_initializers_superInvocation_unnamed() {
|
| - checkLibrary('''
|
| -class A {
|
| - const A(int p);
|
| -}
|
| -class C extends A {
|
| - const C.ccc() : super(42);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_initializers_thisInvocation_named() {
|
| - checkLibrary('''
|
| -class C {
|
| - const C() : this.named(1, 'bbb');
|
| - const C.named(int a, String b);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_initializers_thisInvocation_namedExpression() {
|
| - checkLibrary('''
|
| -class C {
|
| - const C() : this.named(1, b: 2);
|
| - const C.named(a, {int b});
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_initializers_thisInvocation_unnamed() {
|
| - checkLibrary('''
|
| -class C {
|
| - const C.named() : this(1, 'bbb');
|
| - const C(int a, String b);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_named() {
|
| - checkLibrary('''
|
| -class C {
|
| - factory C() = D.named;
|
| - C._();
|
| -}
|
| -class D extends C {
|
| - D.named() : super._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_named_generic() {
|
| - checkLibrary('''
|
| -class C<T, U> {
|
| - factory C() = D<U, T>.named;
|
| - C._();
|
| -}
|
| -class D<T, U> extends C<U, T> {
|
| - D.named() : super._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_named_imported() {
|
| - addLibrarySource(
|
| - '/foo.dart',
|
| - '''
|
| -import 'test.dart';
|
| -class D extends C {
|
| - D.named() : super._();
|
| -}
|
| -''');
|
| - checkLibrary('''
|
| -import 'foo.dart';
|
| -class C {
|
| - factory C() = D.named;
|
| - C._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_named_imported_generic() {
|
| - addLibrarySource(
|
| - '/foo.dart',
|
| - '''
|
| -import 'test.dart';
|
| -class D<T, U> extends C<U, T> {
|
| - D.named() : super._();
|
| -}
|
| -''');
|
| - checkLibrary('''
|
| -import 'foo.dart';
|
| -class C<T, U> {
|
| - factory C() = D<U, T>.named;
|
| - C._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_named_prefixed() {
|
| - addLibrarySource(
|
| - '/foo.dart',
|
| - '''
|
| -import 'test.dart';
|
| -class D extends C {
|
| - D.named() : super._();
|
| -}
|
| -''');
|
| - checkLibrary('''
|
| -import 'foo.dart' as foo;
|
| -class C {
|
| - factory C() = foo.D.named;
|
| - C._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_named_prefixed_generic() {
|
| - addLibrarySource(
|
| - '/foo.dart',
|
| - '''
|
| -import 'test.dart';
|
| -class D<T, U> extends C<U, T> {
|
| - D.named() : super._();
|
| -}
|
| -''');
|
| - checkLibrary('''
|
| -import 'foo.dart' as foo;
|
| -class C<T, U> {
|
| - factory C() = foo.D<U, T>.named;
|
| - C._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_unnamed() {
|
| - checkLibrary('''
|
| -class C {
|
| - factory C() = D;
|
| - C._();
|
| -}
|
| -class D extends C {
|
| - D() : super._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_unnamed_generic() {
|
| - checkLibrary('''
|
| -class C<T, U> {
|
| - factory C() = D<U, T>;
|
| - C._();
|
| -}
|
| -class D<T, U> extends C<U, T> {
|
| - D() : super._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_unnamed_imported() {
|
| - addLibrarySource(
|
| - '/foo.dart',
|
| - '''
|
| -import 'test.dart';
|
| -class D extends C {
|
| - D() : super._();
|
| -}
|
| -''');
|
| - checkLibrary('''
|
| -import 'foo.dart';
|
| -class C {
|
| - factory C() = D;
|
| - C._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_unnamed_imported_generic() {
|
| - addLibrarySource(
|
| - '/foo.dart',
|
| - '''
|
| -import 'test.dart';
|
| -class D<T, U> extends C<U, T> {
|
| - D() : super._();
|
| -}
|
| -''');
|
| - checkLibrary('''
|
| -import 'foo.dart';
|
| -class C<T, U> {
|
| - factory C() = D<U, T>;
|
| - C._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_unnamed_prefixed() {
|
| - addLibrarySource(
|
| - '/foo.dart',
|
| - '''
|
| -import 'test.dart';
|
| -class D extends C {
|
| - D() : super._();
|
| -}
|
| -''');
|
| - checkLibrary('''
|
| -import 'foo.dart' as foo;
|
| -class C {
|
| - factory C() = foo.D;
|
| - C._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_factory_unnamed_prefixed_generic() {
|
| - addLibrarySource(
|
| - '/foo.dart',
|
| - '''
|
| -import 'test.dart';
|
| -class D<T, U> extends C<U, T> {
|
| - D() : super._();
|
| -}
|
| -''');
|
| - checkLibrary('''
|
| -import 'foo.dart' as foo;
|
| -class C<T, U> {
|
| - factory C() = foo.D<U, T>;
|
| - C._();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_thisInvocation_named() {
|
| - checkLibrary('''
|
| -class C {
|
| - C.named();
|
| - C() : this.named();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_thisInvocation_named_generic() {
|
| - checkLibrary('''
|
| -class C<T> {
|
| - C.named();
|
| - C() : this.named();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_thisInvocation_unnamed() {
|
| - checkLibrary('''
|
| -class C {
|
| - C();
|
| - C.named() : this();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_redirected_thisInvocation_unnamed_generic() {
|
| - checkLibrary('''
|
| -class C<T> {
|
| - C();
|
| - C.named() : this();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_withCycles_const() {
|
| - checkLibrary('''
|
| -class C {
|
| - final x;
|
| - const C() : x = const D();
|
| -}
|
| -class D {
|
| - final x;
|
| - const D() : x = const C();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_constructor_withCycles_nonConst() {
|
| - checkLibrary('''
|
| -class C {
|
| - final x;
|
| - C() : x = new D();
|
| -}
|
| -class D {
|
| - final x;
|
| - D() : x = new C();
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_defaultValue_refersToGenericClass_constructor() {
|
| - checkLibrary('''
|
| -class B<T> {
|
| - const B();
|
| -}
|
| -class C<T> {
|
| - const C([B<T> b = const B()]);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_defaultValue_refersToGenericClass_constructor2() {
|
| - checkLibrary('''
|
| -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('''
|
| -class B<T> {
|
| - const B();
|
| -}
|
| -void foo<T>([B<T> b = const B()]) {}
|
| -''');
|
| - }
|
| -
|
| - test_defaultValue_refersToGenericClass_methodG() {
|
| - checkLibrary('''
|
| -class B<T> {
|
| - const B();
|
| -}
|
| -class C {
|
| - void foo<T>([B<T> b = const B()]) {}
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_defaultValue_refersToGenericClass_methodG_classG() {
|
| - checkLibrary('''
|
| -class B<T1, T2> {
|
| - const B();
|
| -}
|
| -class C<E1> {
|
| - void foo<E2>([B<E1, E2> b = const B()]) {}
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_defaultValue_refersToGenericClass_methodNG() {
|
| - checkLibrary('''
|
| -class B<T> {
|
| - const B();
|
| -}
|
| -class C<T> {
|
| - void foo([B<T> b = const B()]) {}
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_enum_documented() {
|
| - checkLibrary('''
|
| -// Extra comment so doc comment offset != 0
|
| -/**
|
| - * Docs
|
| - */
|
| -enum E { v }''');
|
| - }
|
| -
|
| - test_enum_value_documented() {
|
| - checkLibrary('''
|
| -enum E {
|
| - /**
|
| - * Docs
|
| - */
|
| - v
|
| -}''');
|
| - }
|
| -
|
| - test_enum_values() {
|
| - checkLibrary('enum E { v1, v2 }');
|
| - }
|
| -
|
| - test_enums() {
|
| - checkLibrary('enum E1 { v1 } enum E2 { v2 }');
|
| - }
|
| -
|
| - test_executable_parameter_type_typedef() {
|
| - checkLibrary(r'''
|
| -typedef F(int p);
|
| -main(F f) {}
|
| -''');
|
| - }
|
| -
|
| - test_export_class() {
|
| - addLibrarySource('/a.dart', 'class C {}');
|
| - checkLibrary('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";');
|
| - }
|
| -
|
| - test_export_configurations_useDefault() {
|
| - context.declaredVariables.define('dart.library.io', 'false');
|
| - addLibrarySource('/foo.dart', 'class A {}');
|
| - addLibrarySource('/foo_io.dart', 'class A {}');
|
| - addLibrarySource('/foo_html.dart', 'class A {}');
|
| - LibraryElementImpl library = checkLibrary(r'''
|
| -export 'foo.dart'
|
| - if (dart.library.io) 'foo_io.dart'
|
| - if (dart.library.html) 'foo_html.dart';
|
| -''');
|
| - expect(library.exports[0].uri, 'foo.dart');
|
| - expect(library.exports[0].exportedLibrary.source.shortName, 'foo.dart');
|
| - }
|
| -
|
| - test_export_configurations_useFirst() {
|
| - context.declaredVariables.define('dart.library.io', 'true');
|
| - context.declaredVariables.define('dart.library.html', 'true');
|
| - addLibrarySource('/foo.dart', 'class A {}');
|
| - addLibrarySource('/foo_io.dart', 'class A {}');
|
| - addLibrarySource('/foo_html.dart', 'class A {}');
|
| - LibraryElementImpl library = checkLibrary(r'''
|
| -export 'foo.dart'
|
| - if (dart.library.io) 'foo_io.dart'
|
| - if (dart.library.html) 'foo_html.dart';
|
| -''');
|
| - expect(library.exports[0].uri, 'foo_io.dart');
|
| - expect(library.exports[0].exportedLibrary.source.shortName, 'foo_io.dart');
|
| - }
|
| -
|
| - test_export_configurations_useSecond() {
|
| - context.declaredVariables.define('dart.library.io', 'false');
|
| - context.declaredVariables.define('dart.library.html', 'true');
|
| - addLibrarySource('/foo.dart', 'class A {}');
|
| - addLibrarySource('/foo_io.dart', 'class A {}');
|
| - addLibrarySource('/foo_html.dart', 'class A {}');
|
| - LibraryElementImpl library = checkLibrary(r'''
|
| -export 'foo.dart'
|
| - if (dart.library.io) 'foo_io.dart'
|
| - if (dart.library.html) 'foo_html.dart';
|
| -''');
|
| - ExportElement export = library.exports[0];
|
| - expect(export.uri, 'foo_html.dart');
|
| - expect(export.exportedLibrary.source.shortName, 'foo_html.dart');
|
| - }
|
| -
|
| - test_export_function() {
|
| - addLibrarySource('/a.dart', 'f() {}');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_export_getter() {
|
| - addLibrarySource('/a.dart', 'get f() => null;');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_export_hide() {
|
| - addLibrary('dart:async');
|
| - checkLibrary('export "dart:async" hide Stream, Future;');
|
| - }
|
| -
|
| - test_export_multiple_combinators() {
|
| - addLibrary('dart:async');
|
| - checkLibrary('export "dart:async" hide Stream show Future;');
|
| - }
|
| -
|
| - test_export_setter() {
|
| - addLibrarySource('/a.dart', 'void set f(value) {}');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_export_show() {
|
| - addLibrary('dart:async');
|
| - checkLibrary('export "dart:async" show Future, Stream;');
|
| - }
|
| -
|
| - test_export_typedef() {
|
| - addLibrarySource('/a.dart', 'typedef F();');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_export_variable() {
|
| - addLibrarySource('/a.dart', 'var x;');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_export_variable_const() {
|
| - addLibrarySource('/a.dart', 'const x = 0;');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_export_variable_final() {
|
| - addLibrarySource('/a.dart', 'final x = 0;');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_exportImport_configurations_useDefault() {
|
| - context.declaredVariables.define('dart.library.io', 'false');
|
| - addLibrarySource('/foo.dart', 'class A {}');
|
| - addLibrarySource('/foo_io.dart', 'class A {}');
|
| - addLibrarySource('/foo_html.dart', 'class A {}');
|
| - addLibrarySource(
|
| - '/bar.dart',
|
| - r'''
|
| -export 'foo.dart'
|
| - if (dart.library.io) 'foo_io.dart'
|
| - if (dart.library.html) 'foo_html.dart';
|
| -''');
|
| - LibraryElementImpl library = checkLibrary(r'''
|
| -import 'bar.dart';
|
| -class B extends A {}
|
| -''');
|
| - var typeA = library.definingCompilationUnit.getType('B').supertype;
|
| - expect(typeA.element.source.shortName, 'foo.dart');
|
| - }
|
| -
|
| - test_exportImport_configurations_useFirst() {
|
| - context.declaredVariables.define('dart.library.io', 'true');
|
| - context.declaredVariables.define('dart.library.html', 'true');
|
| - addLibrarySource('/foo.dart', 'class A {}');
|
| - addLibrarySource('/foo_io.dart', 'class A {}');
|
| - addLibrarySource('/foo_html.dart', 'class A {}');
|
| - addLibrarySource(
|
| - '/bar.dart',
|
| - r'''
|
| -export 'foo.dart'
|
| - if (dart.library.io) 'foo_io.dart'
|
| - if (dart.library.html) 'foo_html.dart';
|
| -''');
|
| - var library = checkLibrary(r'''
|
| -import 'bar.dart';
|
| -class B extends A {}
|
| -''');
|
| - var typeA = library.definingCompilationUnit.getType('B').supertype;
|
| - expect(typeA.element.source.shortName, 'foo_io.dart');
|
| - }
|
| -
|
| - test_exports() {
|
| - addLibrarySource('/a.dart', 'library a;');
|
| - addLibrarySource('/b.dart', 'library b;');
|
| - checkLibrary('export "a.dart"; export "b.dart";');
|
| - }
|
| -
|
| - test_field_documented() {
|
| - checkLibrary('''
|
| -class C {
|
| - /**
|
| - * Docs
|
| - */
|
| - var x;
|
| -}''');
|
| - }
|
| -
|
| - test_field_formal_param_inferred_type_implicit() {
|
| - checkLibrary('class C extends D { var v; C(this.v); }'
|
| - ' abstract class D { int get v; }');
|
| - }
|
| -
|
| - test_field_inferred_type_nonStatic_explicit_initialized() {
|
| - checkLibrary('class C { num v = 0; }');
|
| - }
|
| -
|
| - test_field_inferred_type_nonStatic_implicit_initialized() {
|
| - checkLibrary('class C { var v = 0; }');
|
| - }
|
| -
|
| - test_field_inferred_type_nonStatic_implicit_uninitialized() {
|
| - checkLibrary(
|
| - 'class C extends D { var v; } abstract class D { int get v; }');
|
| - }
|
| -
|
| - test_field_inferred_type_static_implicit_initialized() {
|
| - checkLibrary('class C { static var v = 0; }');
|
| - }
|
| -
|
| - test_field_propagatedType_const_noDep() {
|
| - checkLibrary('''
|
| -class C {
|
| - static const x = 0;
|
| -}''');
|
| - }
|
| -
|
| - test_field_propagatedType_final_dep_inLib() {
|
| - addLibrarySource('/a.dart', 'final a = 1;');
|
| - checkLibrary('''
|
| -import "a.dart";
|
| -class C {
|
| - final b = a / 2;
|
| -}''');
|
| - }
|
| -
|
| - test_field_propagatedType_final_dep_inPart() {
|
| - addSource('/a.dart', 'part of lib; final a = 1;');
|
| - checkLibrary('''
|
| -library lib;
|
| -part "a.dart";
|
| -class C {
|
| - final b = a / 2;
|
| -}''');
|
| - }
|
| -
|
| - test_field_propagatedType_final_noDep_instance() {
|
| - checkLibrary('''
|
| -class C {
|
| - final x = 0;
|
| -}''');
|
| - }
|
| -
|
| - test_field_propagatedType_final_noDep_static() {
|
| - checkLibrary('''
|
| -class C {
|
| - static final x = 0;
|
| -}''');
|
| - }
|
| -
|
| - test_field_static_final_untyped() {
|
| - checkLibrary('class C { static final x = 0; }');
|
| - }
|
| -
|
| - test_field_untyped() {
|
| - checkLibrary('class C { var x = 0; }');
|
| - }
|
| -
|
| - test_function_async() {
|
| - checkLibrary(r'''
|
| -import 'dart:async';
|
| -Future f() async {}
|
| -''');
|
| - }
|
| -
|
| - test_function_asyncStar() {
|
| - checkLibrary(r'''
|
| -import 'dart:async';
|
| -Stream f() async* {}
|
| -''');
|
| - }
|
| -
|
| - test_function_documented() {
|
| - checkLibrary('''
|
| -// Extra comment so doc comment offset != 0
|
| -/**
|
| - * Docs
|
| - */
|
| -f() {}''');
|
| - }
|
| -
|
| - test_function_entry_point() {
|
| - checkLibrary('main() {}');
|
| - }
|
| -
|
| - test_function_entry_point_in_export() {
|
| - addLibrarySource('/a.dart', 'library a; main() {}');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_function_entry_point_in_export_hidden() {
|
| - addLibrarySource('/a.dart', 'library a; main() {}');
|
| - checkLibrary('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";');
|
| - }
|
| -
|
| - test_function_external() {
|
| - checkLibrary('external f();');
|
| - }
|
| -
|
| - test_function_parameter_kind_named() {
|
| - checkLibrary('f({x}) {}');
|
| - }
|
| -
|
| - test_function_parameter_kind_positional() {
|
| - checkLibrary('f([x]) {}');
|
| - }
|
| -
|
| - test_function_parameter_kind_required() {
|
| - checkLibrary('f(x) {}');
|
| - }
|
| -
|
| - test_function_parameter_parameters() {
|
| - checkLibrary('f(g(x, y)) {}');
|
| - }
|
| -
|
| - test_function_parameter_return_type() {
|
| - checkLibrary('f(int g()) {}');
|
| - }
|
| -
|
| - test_function_parameter_return_type_void() {
|
| - checkLibrary('f(void g()) {}');
|
| - }
|
| -
|
| - test_function_parameter_type() {
|
| - checkLibrary('f(int i) {}');
|
| - }
|
| -
|
| - test_function_parameters() {
|
| - checkLibrary('f(x, y) {}');
|
| - }
|
| -
|
| - test_function_return_type() {
|
| - checkLibrary('int f() => null;');
|
| - }
|
| -
|
| - test_function_return_type_implicit() {
|
| - checkLibrary('f() => null;');
|
| - }
|
| -
|
| - test_function_return_type_void() {
|
| - checkLibrary('void f() {}');
|
| - }
|
| -
|
| - test_function_type_parameter() {
|
| - prepareAnalysisContext(createOptions()..enableGenericMethods = true);
|
| - checkLibrary('T f<T, U>(U u) => null;');
|
| - }
|
| -
|
| - test_function_type_parameter_with_function_typed_parameter() {
|
| - prepareAnalysisContext(createOptions()..enableGenericMethods = true);
|
| - checkLibrary('void f<T, U>(T x(U u)) {}');
|
| - }
|
| -
|
| - test_functions() {
|
| - checkLibrary('f() {} g() {}');
|
| - }
|
| -
|
| - test_generic_gClass_gMethodStatic() {
|
| - prepareAnalysisContext(createOptions()..enableGenericMethods = true);
|
| - 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) {
|
| - }
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_getElement_constructor_named() {
|
| - String text = 'class C { C.named(); }';
|
| - Source source = addLibrarySource('/test.dart', text);
|
| - ConstructorElement original = context
|
| - .computeLibraryElement(source)
|
| - .getType('C')
|
| - .getNamedConstructor('named');
|
| - expect(original, isNotNull);
|
| - ConstructorElement resynthesized = validateGetElement(text, original);
|
| - compareConstructorElements(resynthesized, original, 'C.constructor named');
|
| - }
|
| -
|
| - test_getElement_constructor_unnamed() {
|
| - String text = 'class C { C(); }';
|
| - Source source = addLibrarySource('/test.dart', text);
|
| - ConstructorElement original =
|
| - context.computeLibraryElement(source).getType('C').unnamedConstructor;
|
| - expect(original, isNotNull);
|
| - ConstructorElement resynthesized = validateGetElement(text, original);
|
| - compareConstructorElements(resynthesized, original, 'C.constructor');
|
| - }
|
| -
|
| - test_getElement_field() {
|
| - String text = 'class C { var f; }';
|
| - Source source = addLibrarySource('/test.dart', text);
|
| - FieldElement original =
|
| - context.computeLibraryElement(source).getType('C').getField('f');
|
| - expect(original, isNotNull);
|
| - FieldElement resynthesized = validateGetElement(text, original);
|
| - compareFieldElements(resynthesized, original, 'C.field f');
|
| - }
|
| -
|
| - test_getElement_getter() {
|
| - String text = 'class C { get f => null; }';
|
| - Source source = addLibrarySource('/test.dart', text);
|
| - PropertyAccessorElement original =
|
| - context.computeLibraryElement(source).getType('C').getGetter('f');
|
| - expect(original, isNotNull);
|
| - PropertyAccessorElement resynthesized = validateGetElement(text, original);
|
| - comparePropertyAccessorElements(resynthesized, original, 'C.getter f');
|
| - }
|
| -
|
| - test_getElement_method() {
|
| - String text = 'class C { f() {} }';
|
| - Source source = addLibrarySource('/test.dart', text);
|
| - MethodElement original =
|
| - context.computeLibraryElement(source).getType('C').getMethod('f');
|
| - expect(original, isNotNull);
|
| - MethodElement resynthesized = validateGetElement(text, original);
|
| - compareMethodElements(resynthesized, original, 'C.method f');
|
| - }
|
| -
|
| - test_getElement_operator() {
|
| - String text = 'class C { operator+(x) => null; }';
|
| - Source source = addLibrarySource('/test.dart', text);
|
| - MethodElement original =
|
| - context.computeLibraryElement(source).getType('C').getMethod('+');
|
| - expect(original, isNotNull);
|
| - MethodElement resynthesized = validateGetElement(text, original);
|
| - compareMethodElements(resynthesized, original, 'C.operator+');
|
| - }
|
| -
|
| - test_getElement_setter() {
|
| - String text = 'class C { void set f(value) {} }';
|
| - Source source = addLibrarySource('/test.dart', text);
|
| - PropertyAccessorElement original =
|
| - context.computeLibraryElement(source).getType('C').getSetter('f');
|
| - expect(original, isNotNull);
|
| - PropertyAccessorElement resynthesized = validateGetElement(text, original);
|
| - comparePropertyAccessorElements(resynthesized, original, 'C.setter f');
|
| - }
|
| -
|
| - test_getElement_unit() {
|
| - String text = 'class C { f() {} }';
|
| - Source source = addLibrarySource('/test.dart', text);
|
| - CompilationUnitElement original =
|
| - context.computeLibraryElement(source).definingCompilationUnit;
|
| - expect(original, isNotNull);
|
| - CompilationUnitElement resynthesized = validateGetElement(text, original);
|
| - compareCompilationUnitElements(resynthesized, original);
|
| - }
|
| -
|
| - test_getter_documented() {
|
| - checkLibrary('''
|
| -// Extra comment so doc comment offset != 0
|
| -/**
|
| - * Docs
|
| - */
|
| -get x => null;''');
|
| - }
|
| -
|
| - test_getter_external() {
|
| - checkLibrary('external int get x;');
|
| - }
|
| -
|
| - test_getter_inferred_type_nonStatic_implicit_return() {
|
| - checkLibrary(
|
| - 'class C extends D { get f => null; } abstract class D { int get f; }');
|
| - }
|
| -
|
| - test_getters() {
|
| - checkLibrary('int get x => null; get y => null;');
|
| - }
|
| -
|
| - test_implicitTopLevelVariable_getterFirst() {
|
| - checkLibrary('int get x => 0; void set x(int value) {}');
|
| - }
|
| -
|
| - test_implicitTopLevelVariable_setterFirst() {
|
| - checkLibrary('void set x(int value) {} int get x => 0;');
|
| - }
|
| -
|
| - test_import_configurations_useDefault() {
|
| - context.declaredVariables.define('dart.library.io', 'false');
|
| - addLibrarySource('/foo.dart', 'class A {}');
|
| - addLibrarySource('/foo_io.dart', 'class A {}');
|
| - addLibrarySource('/foo_html.dart', 'class A {}');
|
| - var library = checkLibrary(r'''
|
| -import 'foo.dart'
|
| - if (dart.library.io) 'foo_io.dart'
|
| - if (dart.library.html) 'foo_html.dart';
|
| -
|
| -class B extends A {}
|
| -''');
|
| - var typeA = library.definingCompilationUnit.getType('B').supertype;
|
| - expect(typeA.element.source.shortName, 'foo.dart');
|
| - }
|
| -
|
| - test_import_configurations_useFirst() {
|
| - context.declaredVariables.define('dart.library.io', 'true');
|
| - context.declaredVariables.define('dart.library.html', 'true');
|
| - addLibrarySource('/foo.dart', 'class A {}');
|
| - addLibrarySource('/foo_io.dart', 'class A {}');
|
| - addLibrarySource('/foo_html.dart', 'class A {}');
|
| - var library = checkLibrary(r'''
|
| -import 'foo.dart'
|
| - if (dart.library.io) 'foo_io.dart'
|
| - if (dart.library.html) 'foo_html.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(); }');
|
| - }
|
| -
|
| - test_import_hide() {
|
| - addLibrary('dart:async');
|
| - checkLibrary('import "dart:async" hide Stream, Completer; Future f;');
|
| - }
|
| -
|
| - test_import_multiple_combinators() {
|
| - addLibrary('dart:async');
|
| - checkLibrary('import "dart:async" hide Stream show Future; Future f;');
|
| - }
|
| -
|
| - test_import_prefixed() {
|
| - addLibrarySource('/a.dart', 'library a; class C {}');
|
| - checkLibrary('import "a.dart" as a; a.C c;');
|
| - }
|
| -
|
| - test_import_self() {
|
| - LibraryElementImpl resynthesized = checkLibrary('''
|
| -import 'test.dart' as p;
|
| -class C {}
|
| -class D extends p.C {} // Prevent "unused import" warning
|
| -''');
|
| - expect(resynthesized.imports, hasLength(2));
|
| - expect(resynthesized.imports[0].importedLibrary.location,
|
| - resynthesized.location);
|
| - expect(resynthesized.imports[1].importedLibrary.isDartCore, true);
|
| - }
|
| -
|
| - test_import_show() {
|
| - addLibrary('dart:async');
|
| - checkLibrary('''
|
| -import "dart:async" show Future, Stream;
|
| -Future f;
|
| -Stream 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;');
|
| - }
|
| -
|
| - 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('''
|
| -f<U, V>() {
|
| - var x = () => 0;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - 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('''
|
| -class C<U, V> {
|
| - final x;
|
| - C() : x = (() => () => 0);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - 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('''
|
| -class C<U, V> {
|
| - get x => () => () => 0;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - 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('''
|
| -class C<T> {
|
| - f<U, V>() {
|
| - print(() => () => 0);
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - 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('''
|
| -class C<U, V> {
|
| - void set x(value) {
|
| - print(() => () => 0);
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_inferred_function_type_in_generic_closure() {
|
| - if (!createOptions().strongMode) {
|
| - // The test below uses generic comment syntax because proper generic
|
| - // method syntax doesn't support generic closures. So it can only run in
|
| - // strong mode.
|
| - // TODO(paulberry): once proper generic method syntax supports generic
|
| - // closures, rewrite the test below without using generic comment syntax,
|
| - // and remove this hack. See dartbug.com/25819
|
| - return;
|
| - }
|
| - // In the code below, `<U, V>() => () => 0` has an inferred return type of
|
| - // `() => int`, with 3 (unused) type parameters.
|
| - checkLibrary('''
|
| -f<T>() {
|
| - print(/*<U, V>*/() => () => 0);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_inferred_generic_function_type_in_generic_closure() {
|
| - if (!createOptions().strongMode) {
|
| - // The test below uses generic comment syntax because proper generic
|
| - // method syntax doesn't support generic closures. So it can only run in
|
| - // strong mode.
|
| - // TODO(paulberry): once proper generic method syntax supports generic
|
| - // closures, rewrite the test below without using generic comment syntax,
|
| - // and remove this hack. See dartbug.com/25819
|
| - return;
|
| - }
|
| - // In the code below, `<U, V>() => <W, X, Y, Z>() => 0` has an inferred
|
| - // return type of `() => int`, with 7 (unused) type parameters.
|
| - checkLibrary('''
|
| -f<T>() {
|
| - print(/*<U, V>*/() => /*<W, X, Y, Z>*/() => 0);
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_inferred_type_is_typedef() {
|
| - checkLibrary('typedef int F(String s);'
|
| - ' class C extends D { var 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; }'
|
| - ' abstract class D<U, V> { Map<V, U> get v; }');
|
| - }
|
| -
|
| - void test_inferred_type_refers_to_function_typed_param_of_typedef() {
|
| - checkLibrary('''
|
| -typedef void F(int g(String s));
|
| -h(F f) => null;
|
| -var v = h(/*info:INFERRED_TYPE_CLOSURE*/(y) {});
|
| -''');
|
| - }
|
| -
|
| - 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)); }');
|
| - }
|
| -
|
| - test_inferred_type_refers_to_function_typed_parameter_type_other_lib() {
|
| - addLibrarySource(
|
| - '/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) {} }');
|
| - }
|
| -
|
| - test_inferred_type_refers_to_method_function_typed_parameter_type() {
|
| - checkLibrary('class C extends D { void f(int x, g) {} }'
|
| - ' abstract class D { void f(int x, int g(String s)); }');
|
| - }
|
| -
|
| - test_inferred_type_refers_to_nested_function_typed_param() {
|
| - checkLibrary('''
|
| -f(void g(int x, void h())) => null;
|
| -var v = f((x, y) {});
|
| -''');
|
| - }
|
| -
|
| - test_inferred_type_refers_to_nested_function_typed_param_named() {
|
| - checkLibrary('''
|
| -f({void g(int x, void h())}) => null;
|
| -var v = f(g: (x, y) {});
|
| -''');
|
| - }
|
| -
|
| - test_inferred_type_refers_to_setter_function_typed_parameter_type() {
|
| - checkLibrary('class C extends D { void set f(g) {} }'
|
| - ' abstract class D { void set f(int g(String s)); }');
|
| - }
|
| -
|
| - void test_inferredType_usesSyntheticFunctionType_functionTypedParam() {
|
| - checkLibrary('''
|
| -int f(int x(String y)) => null;
|
| -String g(int x(String y)) => null;
|
| -var v = [f, g];
|
| -''');
|
| - }
|
| -
|
| - test_initializer_executable_with_return_type_from_closure() {
|
| - checkLibrary('var v = () => 0;');
|
| - }
|
| -
|
| - test_initializer_executable_with_return_type_from_closure_field() {
|
| - checkLibrary('''
|
| -class C {
|
| - var v = () => 0;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_initializer_executable_with_return_type_from_closure_local() {
|
| - checkLibrary('''
|
| -void f() {
|
| - int u = 0;
|
| - var v = () => 0;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_instantiateToBounds_boundRefersToEarlierTypeArgument() {
|
| - checkLibrary('''
|
| -class C<S extends num, T extends C<S, T>> {}
|
| -C c;
|
| -''');
|
| - }
|
| -
|
| - test_instantiateToBounds_boundRefersToItself() {
|
| - checkLibrary('''
|
| -class C<T extends C<T>> {}
|
| -C c;
|
| -''');
|
| - }
|
| -
|
| - test_instantiateToBounds_boundRefersToLaterTypeArgument() {
|
| - checkLibrary('''
|
| -class C<T extends C<T, U>, U extends num> {}
|
| -C c;
|
| -''');
|
| - }
|
| -
|
| - test_instantiateToBounds_simple() {
|
| - checkLibrary('''
|
| -class C<T extends num> {}
|
| -C c;
|
| -''');
|
| - }
|
| -
|
| - test_library() {
|
| - checkLibrary('');
|
| - }
|
| -
|
| - test_library_documented() {
|
| - checkLibrary('''
|
| -// Extra comment so doc comment offset != 0
|
| -/**
|
| - * Docs
|
| - */
|
| -library foo;''');
|
| - }
|
| -
|
| - test_library_name_with_spaces() {
|
| - checkLibrary('library foo . bar ;');
|
| - }
|
| -
|
| - test_library_named() {
|
| - checkLibrary('library foo.bar;');
|
| - }
|
| -
|
| - test_localFunctions() {
|
| - checkLibrary(r'''
|
| -f() {
|
| - f1() {}
|
| - {
|
| - f2() {}
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_localFunctions_inConstructor() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - C() {
|
| - f() {}
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_localFunctions_inMethod() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - m() {
|
| - f() {}
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_localFunctions_inTopLevelGetter() {
|
| - checkLibrary(r'''
|
| -get g {
|
| - f() {}
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_localLabels_inConstructor() {
|
| - checkLibrary(
|
| - r'''
|
| -class C {
|
| - C() {
|
| - aaa: while (true) {}
|
| - bbb: switch (42) {
|
| - ccc: case 0:
|
| - break;
|
| - }
|
| - }
|
| -}
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_localLabels_inMethod() {
|
| - checkLibrary(
|
| - r'''
|
| -class C {
|
| - m() {
|
| - aaa: while (true) {}
|
| - bbb: switch (42) {
|
| - ccc: case 0:
|
| - break;
|
| - }
|
| - }
|
| -}
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_localLabels_inTopLevelFunction() {
|
| - checkLibrary(
|
| - r'''
|
| -main() {
|
| - aaa: while (true) {}
|
| - bbb: switch (42) {
|
| - ccc: case 0:
|
| - break;
|
| - }
|
| -}
|
| -''',
|
| - allowErrors: true);
|
| - }
|
| -
|
| - test_localVariables_inConstructor() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - C() {
|
| - int v;
|
| - f() {}
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_localVariables_inLocalFunction() {
|
| - checkLibrary(r'''
|
| -f() {
|
| - f1() {
|
| - int v1 = 1;
|
| - } // 2
|
| - f2() {
|
| - int v1 = 1;
|
| - f3() {
|
| - int v2 = 1;
|
| - }
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_localVariables_inMethod() {
|
| - checkLibrary(r'''
|
| -class C {
|
| - m() {
|
| - int v;
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_localVariables_inTopLevelFunction() {
|
| - checkLibrary(r'''
|
| -main() {
|
| - int v1 = 1;
|
| - {
|
| - const String v2 = 'bbb';
|
| - }
|
| - Map<int, List<double>> v3;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_localVariables_inTopLevelGetter() {
|
| - checkLibrary(r'''
|
| -get g {
|
| - int v;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_main_class() {
|
| - checkLibrary('class main {}');
|
| - }
|
| -
|
| - test_main_class_alias() {
|
| - checkLibrary('class main = C with D; 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";');
|
| - }
|
| -
|
| - test_main_class_via_export() {
|
| - addLibrarySource('/a.dart', 'class main {}');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_main_getter() {
|
| - checkLibrary('get main => null;');
|
| - }
|
| -
|
| - test_main_getter_via_export() {
|
| - addLibrarySource('/a.dart', 'get main => null;');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_main_typedef() {
|
| - checkLibrary('typedef main();');
|
| - }
|
| -
|
| - test_main_typedef_via_export() {
|
| - addLibrarySource('/a.dart', 'typedef main();');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_main_variable() {
|
| - checkLibrary('var main;');
|
| - }
|
| -
|
| - test_main_variable_via_export() {
|
| - addLibrarySource('/a.dart', 'var main;');
|
| - checkLibrary('export "a.dart";');
|
| - }
|
| -
|
| - test_member_function_async() {
|
| - checkLibrary(r'''
|
| -import 'dart:async';
|
| -class C {
|
| - Future f() async {}
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_member_function_asyncStar() {
|
| - checkLibrary(r'''
|
| -import 'dart:async';
|
| -class C {
|
| - Stream f() async* {}
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_metadata_classDeclaration() {
|
| - checkLibrary('const a = null; @a class C {}');
|
| - }
|
| -
|
| - test_metadata_classTypeAlias() {
|
| - checkLibrary(
|
| - 'const a = null; @a class C = D with E; class D {} class E {}');
|
| - }
|
| -
|
| - test_metadata_constructor_call_named() {
|
| - checkLibrary('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 {}');
|
| - }
|
| -
|
| - test_metadata_constructor_call_unnamed() {
|
| - checkLibrary('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 {}');
|
| - }
|
| -
|
| - test_metadata_constructor_call_with_args() {
|
| - checkLibrary('class A { const A(x); } @A(null) class C {}');
|
| - }
|
| -
|
| - test_metadata_constructorDeclaration_named() {
|
| - checkLibrary('const a = null; class C { @a C.named(); }');
|
| - }
|
| -
|
| - test_metadata_constructorDeclaration_unnamed() {
|
| - checkLibrary('const a = null; class C { @a C(); }');
|
| - }
|
| -
|
| - test_metadata_enumDeclaration() {
|
| - checkLibrary('const a = null; @a enum E { v }');
|
| - }
|
| -
|
| - test_metadata_exportDirective() {
|
| - addLibrarySource('/foo.dart', '');
|
| - checkLibrary('@a export "foo.dart"; const a = null;');
|
| - }
|
| -
|
| - test_metadata_fieldDeclaration() {
|
| - checkLibrary('const a = null; class C { @a int x; }');
|
| - }
|
| -
|
| - test_metadata_fieldFormalParameter() {
|
| - checkLibrary('const a = null; class C { var x; C(@a this.x); }');
|
| - }
|
| -
|
| - test_metadata_fieldFormalParameter_withDefault() {
|
| - checkLibrary('const a = null; class C { var x; C([@a this.x = null]); }');
|
| - }
|
| -
|
| - test_metadata_functionDeclaration_function() {
|
| - checkLibrary('const a = null; @a f() {}');
|
| - }
|
| -
|
| - test_metadata_functionDeclaration_getter() {
|
| - checkLibrary('const a = null; @a get f => null;');
|
| - }
|
| -
|
| - test_metadata_functionDeclaration_setter() {
|
| - checkLibrary('const a = null; @a set f(value) {}');
|
| - }
|
| -
|
| - test_metadata_functionTypeAlias() {
|
| - checkLibrary('const a = null; @a typedef F();');
|
| - }
|
| -
|
| - test_metadata_functionTypedFormalParameter() {
|
| - checkLibrary('const a = null; f(@a g()) {}');
|
| - }
|
| -
|
| - test_metadata_functionTypedFormalParameter_withDefault() {
|
| - checkLibrary('const a = null; f([@a g() = null]) {}');
|
| - }
|
| -
|
| - test_metadata_importDirective() {
|
| - addLibrarySource('/foo.dart', 'const b = null;');
|
| - checkLibrary('@a import "foo.dart"; const a = b;');
|
| - }
|
| -
|
| - test_metadata_libraryDirective() {
|
| - checkLibrary('@a library L; const a = null;');
|
| - }
|
| -
|
| - test_metadata_methodDeclaration_getter() {
|
| - checkLibrary('const a = null; class C { @a get m => null; }');
|
| - }
|
| -
|
| - test_metadata_methodDeclaration_method() {
|
| - checkLibrary('const a = null; class C { @a m() {} }');
|
| - }
|
| -
|
| - test_metadata_methodDeclaration_setter() {
|
| - checkLibrary('const a = null; class C { @a set m(value) {} }');
|
| - }
|
| -
|
| - test_metadata_partDirective() {
|
| - addSource('/foo.dart', 'part of L;');
|
| - checkLibrary('library L; @a part "foo.dart"; const a = null;');
|
| - }
|
| -
|
| - test_metadata_prefixed_variable() {
|
| - addLibrarySource('/a.dart', 'const b = null;');
|
| - checkLibrary('import "a.dart" as a; @a.b class C {}');
|
| - }
|
| -
|
| - test_metadata_simpleFormalParameter() {
|
| - checkLibrary('const a = null; f(@a x) {}');
|
| - }
|
| -
|
| - test_metadata_simpleFormalParameter_withDefault() {
|
| - checkLibrary('const a = null; f([@a x = null]) {}');
|
| - }
|
| -
|
| - test_metadata_topLevelVariableDeclaration() {
|
| - checkLibrary('const a = null; @a int v;');
|
| - }
|
| -
|
| - test_metadata_typeParameter_ofClass() {
|
| - checkLibrary('const a = null; class C<@a T> {}');
|
| - }
|
| -
|
| - test_metadata_typeParameter_ofClassTypeAlias() {
|
| - checkLibrary(
|
| - 'const a = null; class C<@a T> = D with E; class D {} class E {}');
|
| - }
|
| -
|
| - test_metadata_typeParameter_ofFunction() {
|
| - checkLibrary('const a = null; f<@a T>() {}');
|
| - }
|
| -
|
| - test_metadata_typeParameter_ofTypedef() {
|
| - checkLibrary('const a = null; typedef F<@a T>();');
|
| - }
|
| -
|
| - test_method_documented() {
|
| - checkLibrary('''
|
| -class C {
|
| - /**
|
| - * Docs
|
| - */
|
| - f() {}
|
| -}''');
|
| - }
|
| -
|
| - test_method_inferred_type_nonStatic_implicit_param() {
|
| - checkLibrary('class C extends D { void f(value) {} }'
|
| - ' abstract class D { void f(int value); }');
|
| - }
|
| -
|
| - test_method_inferred_type_nonStatic_implicit_return() {
|
| - checkLibrary(
|
| - 'class C extends D { f() => null; } abstract class D { int f(); }');
|
| - }
|
| -
|
| - test_method_parameter_parameters() {
|
| - checkLibrary('class C { f(g(x, y)) {} }');
|
| - }
|
| -
|
| - test_method_parameter_parameters_in_generic_class() {
|
| - checkLibrary('class C<A, B> { f(A g(B x)) {} }');
|
| - }
|
| -
|
| - test_method_parameter_return_type() {
|
| - checkLibrary('class C { f(int g()) {} }');
|
| - }
|
| -
|
| - test_method_parameter_return_type_void() {
|
| - checkLibrary('class C { f(void g()) {} }');
|
| - }
|
| -
|
| - test_method_type_parameter() {
|
| - prepareAnalysisContext(createOptions()..enableGenericMethods = true);
|
| - checkLibrary('class C { T f<T, U>(U u) => null; }');
|
| - }
|
| -
|
| - test_method_type_parameter_in_generic_class() {
|
| - prepareAnalysisContext(createOptions()..enableGenericMethods = true);
|
| - checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
|
| - }
|
| -
|
| - test_method_type_parameter_with_function_typed_parameter() {
|
| - prepareAnalysisContext(createOptions()..enableGenericMethods = true);
|
| - checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
|
| - }
|
| -
|
| - test_nested_generic_functions_in_generic_class_with_function_typed_params() {
|
| - 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)) {
|
| - }
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_nested_generic_functions_in_generic_class_with_local_variables() {
|
| - checkLibrary('''
|
| -class C<T, U> {
|
| - void g<V, W>() {
|
| - void h<X, Y>() {
|
| - T t;
|
| - U u;
|
| - V v;
|
| - W w;
|
| - X x;
|
| - Y y;
|
| - }
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_nested_generic_functions_with_function_typed_param() {
|
| - 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)) {
|
| - }
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_nested_generic_functions_with_local_variables() {
|
| - checkLibrary('''
|
| -void f<T, U>() {
|
| - void g<V, W>() {
|
| - void h<X, Y>() {
|
| - T t;
|
| - U u;
|
| - V v;
|
| - W w;
|
| - X x;
|
| - Y y;
|
| - }
|
| - }
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_operator() {
|
| - checkLibrary('class C { C operator+(C other) => null; }');
|
| - }
|
| -
|
| - test_operator_equal() {
|
| - checkLibrary('class C { bool operator==(Object other) => false; }');
|
| - }
|
| -
|
| - test_operator_external() {
|
| - checkLibrary('class C { external C operator+(C other); }');
|
| - }
|
| -
|
| - test_operator_greater_equal() {
|
| - checkLibrary('class C { bool operator>=(C other) => false; }');
|
| - }
|
| -
|
| - test_operator_index() {
|
| - checkLibrary('class C { bool operator[](int i) => null; }');
|
| - }
|
| -
|
| - test_operator_index_set() {
|
| - checkLibrary('class C { void operator[]=(int i, bool v) {} }');
|
| - }
|
| -
|
| - test_operator_less_equal() {
|
| - checkLibrary('class C { bool operator<=(C other) => false; }');
|
| - }
|
| -
|
| - 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('''
|
| -class C {
|
| - C.positional([x = 1]);
|
| - C.named({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('''
|
| -class C {
|
| - var x;
|
| - C.positional([this.x = 1]);
|
| - C.named({this.x: 1});
|
| -}
|
| -''');
|
| - }
|
| -
|
| - 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('''
|
| -class C {
|
| - static void positional([x = 1]) {}
|
| - static void named({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('''
|
| -void positional([x = 1]) {}
|
| -void named({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";');
|
| - }
|
| -
|
| - test_propagated_type_refers_to_closure() {
|
| - checkLibrary('''
|
| -void f() {
|
| - var x = () => 0;
|
| - var y = x;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_setter_documented() {
|
| - checkLibrary('''
|
| -// Extra comment so doc comment offset != 0
|
| -/**
|
| - * Docs
|
| - */
|
| -void set x(value) {}''');
|
| - }
|
| -
|
| - test_setter_external() {
|
| - checkLibrary('external void set x(int value);');
|
| - }
|
| -
|
| - test_setter_inferred_type_nonStatic_implicit_param() {
|
| - checkLibrary('class C extends D { void set f(value) {} }'
|
| - ' abstract class D { void set f(int value); }');
|
| - }
|
| -
|
| - test_setter_inferred_type_static_implicit_return() {
|
| - checkLibrary('class C { static set f(int value) {} }');
|
| - }
|
| -
|
| - test_setter_inferred_type_top_level_implicit_return() {
|
| - checkLibrary('set f(int value) {}');
|
| - }
|
| -
|
| - test_setters() {
|
| - checkLibrary('void set x(int value) {} set y(value) {}');
|
| - }
|
| -
|
| - test_syntheticFunctionType_genericClosure() {
|
| - if (!createOptions().strongMode) {
|
| - // The test below uses generic comment syntax because proper generic
|
| - // method syntax doesn't support generic closures. So it can only run in
|
| - // strong mode.
|
| - // TODO(paulberry): once proper generic method syntax supports generic
|
| - // closures, rewrite the test below without using generic comment syntax,
|
| - // and remove this hack. See dartbug.com/25819
|
| - return;
|
| - }
|
| - checkLibrary('''
|
| -final v = f() ? /*<T>*/(T t) => 0 : /*<T>*/(T t) => 1;
|
| -bool f() => true;
|
| -''');
|
| - }
|
| -
|
| - test_syntheticFunctionType_genericClosure_inGenericFunction() {
|
| - if (!createOptions().strongMode) {
|
| - // The test below uses generic comment syntax because proper generic
|
| - // method syntax doesn't support generic closures. So it can only run in
|
| - // strong mode.
|
| - // TODO(paulberry): once proper generic method syntax supports generic
|
| - // closures, rewrite the test below without using generic comment syntax,
|
| - // and remove this hack. See dartbug.com/25819
|
| - return;
|
| - }
|
| - 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;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_syntheticFunctionType_inGenericClass() {
|
| - checkLibrary('''
|
| -class C<T, U> {
|
| - var v = f() ? (T t, U u) => 0 : (T t, U u) => 1;
|
| -}
|
| -bool f() => false;
|
| -''');
|
| - }
|
| -
|
| - test_syntheticFunctionType_inGenericFunction() {
|
| - checkLibrary('''
|
| -void f<T, U>(bool b) {
|
| - var v = b ? (T t, U u) => 0 : (T t, U u) => 1;
|
| -}
|
| -''');
|
| - }
|
| -
|
| - test_syntheticFunctionType_noArguments() {
|
| - checkLibrary('''
|
| -final v = f() ? () => 0 : () => 1;
|
| -bool f() => true;
|
| -''');
|
| - }
|
| -
|
| - test_syntheticFunctionType_withArguments() {
|
| - checkLibrary('''
|
| -final v = f() ? (int x, String y) => 0 : (int x, String y) => 1;
|
| -bool f() => true;
|
| -''');
|
| - }
|
| -
|
| - test_type_arguments_explicit_dynamic_dynamic() {
|
| - checkLibrary('Map<dynamic, dynamic> m;');
|
| - }
|
| -
|
| - test_type_arguments_explicit_dynamic_int() {
|
| - checkLibrary('Map<dynamic, int> m;');
|
| - }
|
| -
|
| - test_type_arguments_explicit_String_dynamic() {
|
| - checkLibrary('Map<String, dynamic> m;');
|
| - }
|
| -
|
| - test_type_arguments_explicit_String_int() {
|
| - checkLibrary('Map<String, int> m;');
|
| - }
|
| -
|
| - test_type_arguments_implicit() {
|
| - checkLibrary('Map m;');
|
| - }
|
| -
|
| - test_type_dynamic() {
|
| - checkLibrary('dynamic d;');
|
| - }
|
| -
|
| - test_type_reference_lib_to_lib() {
|
| - checkLibrary('class C {} enum E { v } typedef F(); 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;');
|
| - }
|
| -
|
| - test_type_reference_part_to_lib() {
|
| - addSource('/a.dart', 'part of l; C c; E e; F f;');
|
| - checkLibrary(
|
| - 'library l; part "a.dart"; class C {} enum E { v } typedef 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";');
|
| - }
|
| -
|
| - 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";');
|
| - }
|
| -
|
| - test_type_reference_to_class() {
|
| - checkLibrary('class C {} C c;');
|
| - }
|
| -
|
| - test_type_reference_to_class_with_type_arguments() {
|
| - checkLibrary('class C<T, U> {} C<int, String> c;');
|
| - }
|
| -
|
| - test_type_reference_to_class_with_type_arguments_implicit() {
|
| - checkLibrary('class C<T, U> {} C c;');
|
| - }
|
| -
|
| - test_type_reference_to_enum() {
|
| - checkLibrary('enum 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;');
|
| - }
|
| -
|
| - 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;');
|
| - }
|
| -
|
| - 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;');
|
| - }
|
| -
|
| - 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;');
|
| - }
|
| -
|
| - 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;');
|
| - }
|
| -
|
| - 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;');
|
| - }
|
| -
|
| - 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;');
|
| - }
|
| -
|
| - 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;');
|
| - }
|
| -
|
| - 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;');
|
| - }
|
| -
|
| - test_type_reference_to_typedef() {
|
| - checkLibrary('typedef F(); F f;');
|
| - }
|
| -
|
| - test_type_reference_to_typedef_with_type_arguments() {
|
| - checkLibrary('typedef U F<T, U>(T t); F<int, String> f;');
|
| - }
|
| -
|
| - test_type_reference_to_typedef_with_type_arguments_implicit() {
|
| - checkLibrary('typedef U F<T, U>(T t); F f;');
|
| - }
|
| -
|
| - test_type_unresolved() {
|
| - checkLibrary('C c;', allowErrors: true);
|
| - }
|
| -
|
| - test_type_unresolved_prefixed() {
|
| - checkLibrary('import "dart:core" as core; core.C c;', allowErrors: true);
|
| - }
|
| -
|
| - test_typedef_documented() {
|
| - checkLibrary('''
|
| -// Extra comment so doc comment offset != 0
|
| -/**
|
| - * Docs
|
| - */
|
| -typedef F();''');
|
| - }
|
| -
|
| - test_typedef_parameter_parameters() {
|
| - checkLibrary('typedef F(g(x, y));');
|
| - }
|
| -
|
| - test_typedef_parameter_parameters_in_generic_class() {
|
| - checkLibrary('typedef F<A, B>(A g(B x));');
|
| - }
|
| -
|
| - test_typedef_parameter_return_type() {
|
| - checkLibrary('typedef F(int g());');
|
| - }
|
| -
|
| - test_typedef_parameter_type() {
|
| - checkLibrary('typedef F(int i);');
|
| - }
|
| -
|
| - test_typedef_parameter_type_generic() {
|
| - checkLibrary('typedef F<T>(T t);');
|
| - }
|
| -
|
| - test_typedef_parameters() {
|
| - checkLibrary('typedef F(x, y);');
|
| - }
|
| -
|
| - test_typedef_return_type() {
|
| - checkLibrary('typedef int F();');
|
| - }
|
| -
|
| - test_typedef_return_type_generic() {
|
| - checkLibrary('typedef T F<T>();');
|
| - }
|
| -
|
| - test_typedef_return_type_implicit() {
|
| - checkLibrary('typedef F();');
|
| - }
|
| -
|
| - test_typedef_return_type_void() {
|
| - checkLibrary('typedef void F();');
|
| - }
|
| -
|
| - test_typedef_type_parameters() {
|
| - checkLibrary('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 {}');
|
| - }
|
| -
|
| - test_typedef_type_parameters_f_bound_complex() {
|
| - checkLibrary('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);');
|
| - }
|
| -
|
| - test_typedefs() {
|
| - checkLibrary('f() {} g() {}');
|
| - }
|
| -
|
| - test_unresolved_export() {
|
| - allowMissingFiles = true;
|
| - checkLibrary("export 'foo.dart';", allowErrors: true);
|
| - }
|
| -
|
| - test_unresolved_import() {
|
| - allowMissingFiles = true;
|
| - checkLibrary("import 'foo.dart';", allowErrors: true);
|
| - }
|
| -
|
| - test_unresolved_part() {
|
| - allowMissingFiles = true;
|
| - checkLibrary("part 'foo.dart';", allowErrors: true);
|
| - }
|
| -
|
| - test_unused_type_parameter() {
|
| - checkLibrary('''
|
| -class C<T> {
|
| - void f() {}
|
| -}
|
| -C<int> c;
|
| -var v = c.f;
|
| -''');
|
| - }
|
| -
|
| - test_variable_const() {
|
| - checkLibrary('const int i = 0;');
|
| - }
|
| -
|
| - test_variable_documented() {
|
| - checkLibrary('''
|
| -// Extra comment so doc comment offset != 0
|
| -/**
|
| - * Docs
|
| - */
|
| -var x;''');
|
| - }
|
| -
|
| - test_variable_final() {
|
| - checkLibrary('final int x = 0;');
|
| - }
|
| -
|
| - test_variable_final_top_level_untyped() {
|
| - checkLibrary('final v = 0;');
|
| - }
|
| -
|
| - 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;');
|
| - }
|
| -
|
| - 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 _) {}');
|
| - }
|
| -
|
| - 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";');
|
| - }
|
| -
|
| - test_variable_implicit_type() {
|
| - checkLibrary('var x;');
|
| - }
|
| -
|
| - test_variable_inferred_type_implicit_initialized() {
|
| - checkLibrary('var v = 0;');
|
| - }
|
| -
|
| - test_variable_propagatedType_const_noDep() {
|
| - checkLibrary('const i = 0;');
|
| - }
|
| -
|
| - test_variable_propagatedType_final_dep_inLib() {
|
| - addLibrarySource('/a.dart', 'final a = 1;');
|
| - checkLibrary('import "a.dart"; final b = a / 2;');
|
| - }
|
| -
|
| - 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;');
|
| - }
|
| -
|
| - test_variable_propagatedType_final_noDep() {
|
| - checkLibrary('final i = 0;');
|
| - }
|
| -
|
| - 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();');
|
| - }
|
| -
|
| - 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";');
|
| - }
|
| -
|
| - test_variables() {
|
| - checkLibrary('int i; int j;');
|
| - }
|
| -
|
| - /**
|
| - * Encode the library containing [original] into a summary and then use
|
| - * [TestSummaryResynthesizer.getElement] to retrieve just the original
|
| - * element from the resynthesized summary.
|
| - */
|
| - Element validateGetElement(String text, Element original) {
|
| - SummaryResynthesizer resynthesizer =
|
| - encodeDecodeLibrarySource(original.library.source);
|
| - ElementLocationImpl location = original.location;
|
| - Element result = resynthesizer.getElement(location);
|
| - checkMinimalResynthesisWork(resynthesizer, original.library);
|
| - // Check that no other summaries needed to be resynthesized to resynthesize
|
| - // the library element.
|
| - expect(resynthesizer.resynthesisCount, 1);
|
| - expect(result.location, location);
|
| - return result;
|
| - }
|
| -}
|
| -
|
| -class TestSummaryResynthesizer extends SummaryResynthesizer {
|
| - final Map<String, UnlinkedUnit> unlinkedSummaries;
|
| - final Map<String, LinkedLibrary> linkedSummaries;
|
| - final bool allowMissingFiles;
|
| -
|
| - /**
|
| - * The set of uris for which unlinked summaries have been requested using
|
| - * [getUnlinkedSummary].
|
| - */
|
| - final Set<String> unlinkedSummariesRequested = new Set<String>();
|
| -
|
| - /**
|
| - * The set of uris for which linked summaries have been requested using
|
| - * [getLinkedSummary].
|
| - */
|
| - final Set<String> linkedSummariesRequested = new Set<String>();
|
| -
|
| - TestSummaryResynthesizer(SummaryResynthesizer parent, AnalysisContext context,
|
| - this.unlinkedSummaries, this.linkedSummaries, this.allowMissingFiles)
|
| - : super(parent, context, context.typeProvider, context.sourceFactory,
|
| - context.analysisOptions.strongMode);
|
| -
|
| - @override
|
| - LinkedLibrary getLinkedSummary(String uri) {
|
| - linkedSummariesRequested.add(uri);
|
| - LinkedLibrary serializedLibrary = linkedSummaries[uri];
|
| - if (serializedLibrary == null && !allowMissingFiles) {
|
| - fail('Unexpectedly tried to get linked summary for $uri');
|
| - }
|
| - return serializedLibrary;
|
| - }
|
| -
|
| - @override
|
| - UnlinkedUnit getUnlinkedSummary(String uri) {
|
| - unlinkedSummariesRequested.add(uri);
|
| - UnlinkedUnit serializedUnit = unlinkedSummaries[uri];
|
| - if (serializedUnit == null && !allowMissingFiles) {
|
| - fail('Unexpectedly tried to get unlinked summary for $uri');
|
| - }
|
| - return serializedUnit;
|
| - }
|
| -
|
| - @override
|
| - bool hasLibrarySummary(String uri) {
|
| - return true;
|
| - }
|
| -}
|
|
|
Chromium Code Reviews
Issue 2353773002:
Remove 'serializeLibrary(LibraryElement)' and its tests. (Closed)
