Implement inheritance/override checks from the spec.
This CL starts moving checks from strong-mode specific checker,
and old InheritanceManager into an implementation that is based
on the current spec, and avoids old baggage. It also fixes the issue
we were asked to fix for Dart 2.1.
Bug: https://github.com/dart-lang/sdk/issues/34392
Change-Id: Id5a23c5db7704b2b530bb894ae92628a08eaa70f
Reviewed-on: https://dart-review.googlesource.com/76061
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
diff --git a/pkg/analyzer/lib/error/error.dart b/pkg/analyzer/lib/error/error.dart
index 7292017..2435013 100644
--- a/pkg/analyzer/lib/error/error.dart
+++ b/pkg/analyzer/lib/error/error.dart
@@ -145,6 +145,8 @@
CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY,
CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE_GETTER_AND_METHOD,
CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD,
CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD,
CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD,
@@ -164,6 +166,7 @@
CompileTimeErrorCode.INVALID_MODIFIER_ON_CONSTRUCTOR,
CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER,
CompileTimeErrorCode.INVALID_INLINE_FUNCTION_TYPE,
+ CompileTimeErrorCode.INVALID_OVERRIDE,
CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS,
CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST,
CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP,
@@ -532,7 +535,6 @@
StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE,
StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE,
StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE,
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER,
StaticTypeWarningCode.INVALID_ASSIGNMENT,
StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION,
@@ -591,14 +593,6 @@
StaticWarningCode.FUNCTION_WITHOUT_CALL,
StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAMED,
StaticWarningCode.IMPORT_OF_NON_LIBRARY,
- StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
- StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE,
- StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE,
- StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE,
- StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE,
- StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE,
- StaticWarningCode.INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS,
- StaticWarningCode.INVALID_METHOD_OVERRIDE_TYPE_PARAMETER_BOUND,
StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED,
StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL,
StaticWarningCode.INVALID_OVERRIDE_NAMED,
@@ -674,9 +668,6 @@
StrongModeCode.INVALID_CAST_METHOD,
StrongModeCode.INVALID_CAST_FUNCTION,
StrongModeCode.INVALID_FIELD_OVERRIDE,
- StrongModeCode.INVALID_METHOD_OVERRIDE,
- StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_BASE,
- StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_MIXIN,
StrongModeCode.INVALID_PARAMETER_DECLARATION,
StrongModeCode.INVALID_SUPER_INVOCATION,
StrongModeCode.NO_DEFAULT_BOUNDS,
diff --git a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
index 3de1ee3..6fe57fe 100644
--- a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
@@ -19,6 +19,7 @@
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/handle.dart';
import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/error/inheritance_override.dart';
import 'package:analyzer/src/error/pending_error.dart';
import 'package:analyzer/src/generated/declaration_resolver.dart';
import 'package:analyzer/src/generated/engine.dart';
@@ -294,14 +295,13 @@
RecordingErrorListener errorListener = _getErrorListener(file);
AnalysisOptionsImpl options = _analysisOptions as AnalysisOptionsImpl;
- CodeChecker checker = new CodeChecker(
- _typeProvider,
- new StrongTypeSystemImpl(_typeProvider,
- implicitCasts: options.implicitCasts,
- declarationCasts: options.declarationCasts,
- nonnullableTypes: options.nonnullableTypes),
- errorListener,
- options);
+ var typeSystem = new StrongTypeSystemImpl(_typeProvider,
+ implicitCasts: options.implicitCasts,
+ declarationCasts: options.declarationCasts,
+ nonnullableTypes: options.nonnullableTypes);
+
+ CodeChecker checker =
+ new CodeChecker(_typeProvider, typeSystem, errorListener, options);
checker.visitCompilationUnit(unit);
ErrorReporter errorReporter = _getErrorReporter(file);
@@ -317,6 +317,13 @@
_computeConstantErrors(errorReporter, unit);
//
+ // Compute inheritance and override errors.
+ //
+ var inheritanceOverrideVerifier =
+ new InheritanceOverrideVerifier(typeSystem, errorReporter);
+ inheritanceOverrideVerifier.verifyUnit(unit);
+
+ //
// Use the ErrorVerifier to compute errors.
//
ErrorVerifier errorVerifier = new ErrorVerifier(
diff --git a/pkg/analyzer/lib/src/dart/element/type.dart b/pkg/analyzer/lib/src/dart/element/type.dart
index fd8c454..a076197 100644
--- a/pkg/analyzer/lib/src/dart/element/type.dart
+++ b/pkg/analyzer/lib/src/dart/element/type.dart
@@ -1761,13 +1761,16 @@
}
ExecutableElement lookUpInheritedMember(String name, LibraryElement library,
- {bool concrete: false, int stopMixinIndex, bool setter: false}) {
+ {bool concrete: false,
+ int startMixinIndex,
+ bool setter: false,
+ bool thisType: false}) {
HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
ExecutableElement lookUpImpl(InterfaceTypeImpl type,
{bool acceptAbstract: false,
bool includeType: true,
- int stopMixinIndex}) {
+ int startMixinIndex}) {
if (type == null || !visitedClasses.add(type.element)) {
return null;
}
@@ -1793,10 +1796,8 @@
}
var mixins = type.mixins;
- for (var i = 0; i < mixins.length; i++) {
- if (stopMixinIndex != null && i >= stopMixinIndex) {
- break;
- }
+ startMixinIndex ??= mixins.length;
+ for (var i = startMixinIndex - 1; i >= 0; i--) {
var result = lookUpImpl(mixins[i], acceptAbstract: acceptAbstract);
if (result != null) {
return result;
@@ -1828,8 +1829,8 @@
} else {
return lookUpImpl(
this,
- includeType: false,
- stopMixinIndex: stopMixinIndex,
+ includeType: thisType,
+ startMixinIndex: startMixinIndex,
);
}
}
diff --git a/pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart b/pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart
index db3945b..2a4d371 100644
--- a/pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart
@@ -15,7 +15,6 @@
import 'package:analyzer/src/dart/element/element.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/type_system.dart';
import 'package:analyzer/src/generated/utilities_dart.dart';
@@ -717,33 +716,9 @@
}
/**
- * This method is used to report errors on when they are found computing inheritance information.
- * See [ErrorVerifier.checkForInconsistentMethodInheritance] to see where these generated
- * error codes are reported back into the analysis engine.
- *
- * @param classElt the location of the source for which the exception occurred
- * @param offset the offset of the location of the error
- * @param length the length of the location of the error
- * @param errorCode the error code to be associated with this error
- * @param arguments the arguments used to build the error message
- */
- void _reportError(
- ClassElement classElt, ErrorCode errorCode, List<Object> arguments) {
- if (ignoreErrors) {
- return;
- }
- HashSet<AnalysisError> errorSet = _errorsInClassElement.putIfAbsent(
- classElt, () => new HashSet<AnalysisError>());
- errorSet.add(new AnalysisError(classElt.source, classElt.nameOffset,
- classElt.nameLength, errorCode, arguments));
- }
-
- /**
* Given the set of methods defined by classes above [classElt] in the class hierarchy,
* apply the appropriate inheritance rules to determine those methods inherited by or overridden
- * by [classElt]. Also report static warnings
- * [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE] and
- * [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD] if appropriate.
+ * by [classElt].
*
* @param classElt the class element to query.
* @param unionMap a mapping from method name to the set of unique (in terms of signature) methods
@@ -838,38 +813,7 @@
//
resultMap[key] = elements[subtypesOfAllOtherTypesIndexes[0]];
} else {
- if (subtypesOfAllOtherTypesIndexes.isEmpty) {
- //
- // Determine if the current class has a method or accessor with
- // the member name, if it does then then this class does not
- // "inherit" from any of the supertypes. See issue 16134.
- //
- bool classHasMember = false;
- if (allMethods) {
- classHasMember = classElt.getMethod(key) != null;
- } else {
- List<PropertyAccessorElement> accessors = classElt.accessors;
- for (int i = 0; i < accessors.length; i++) {
- if (accessors[i].name == key) {
- classHasMember = true;
- }
- }
- }
- //
- // Example: class A inherited only 2 method named 'm'.
- // One has the function type '() -> int' and one has the function
- // type '() -> String'. Since neither is a subtype of the other,
- // we create a warning, and have this class inherit nothing.
- //
- if (!classHasMember) {
- String firstTwoFunctionTypesStr =
- "${executableElementTypes[0]}, ${executableElementTypes[1]}";
- _reportError(
- classElt,
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
- [key, firstTwoFunctionTypesStr]);
- }
- } else {
+ if (!subtypesOfAllOtherTypesIndexes.isEmpty) {
//
// Example: class A inherits 2 methods named 'm'.
// One has the function type '(int) -> dynamic' and one has the
@@ -896,12 +840,6 @@
resultMap[key] = mergedExecutableElement;
}
}
- } else {
- _reportError(
- classElt,
- StaticWarningCode
- .INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
- [key]);
}
}
});
diff --git a/pkg/analyzer/lib/src/error/codes.dart b/pkg/analyzer/lib/src/error/codes.dart
index 37b838c..b1d42a6 100644
--- a/pkg/analyzer/lib/src/error/codes.dart
+++ b/pkg/analyzer/lib/src/error/codes.dart
@@ -1261,6 +1261,46 @@
"Case expressions must have the same types, '{0}' isn't a '{1}'.");
/**
+ * If a class declaration does not have a member declaration with a
+ * particular name, but some super-interfaces do have a member with that
+ * name, it's a compile-time error if there is no signature among the
+ * super-interfaces that is a valid override of all the other super-interface
+ * signatures with the same name. That "most specific" signature becomes the
+ * signature of the class's interface.
+ *
+ * Parameters:
+ * 0: the name of the instance member with inconsistent inheritance.
+ * 1: the list of all inherited signatures for this member.
+ */
+ static const CompileTimeErrorCode INCONSISTENT_INHERITANCE =
+ const CompileTimeErrorCode('INCONSISTENT_INHERITANCE',
+ "Superinterfaces don't have a valid override for '{0}': {1}.",
+ correction:
+ "Try adding an explicit override that is consistent with all "
+ "of the inherited members.");
+
+ /**
+ * 11.1.1 Inheritance and Overriding. Let `I` be the implicit interface of a
+ * class `C` declared in library `L`. `I` inherits all members of
+ * `inherited(I, L)` and `I` overrides `m'` if `m' ∈ overrides(I, L)`. It is
+ * a compile-time error if `m` is a method and `m'` is a getter, or if `m`
+ * is a getter and `m'` is a method.
+ *
+ * Parameters:
+ * 0: the name of the the instance member with inconsistent inheritance.
+ * 1: the name of the superinterface that declares the name as a getter.
+ * 2: the name of the superinterface that declares the name as a method.
+ */
+ static const CompileTimeErrorCode INCONSISTENT_INHERITANCE_GETTER_AND_METHOD =
+ const CompileTimeErrorCode(
+ 'INCONSISTENT_INHERITANCE_GETTER_AND_METHOD',
+ "'{0}' is inherited as a getter (from '{1}') and also a "
+ "method (from '{2}').",
+ correction:
+ "Try adjusting the supertypes of this class to remove the "
+ "inconsistency.");
+
+ /**
* 7.6.1 Generative Constructors: Let <i>k</i> be a generative constructor. It
* is a compile-time error if <i>k</i>'s initializer list contains an
* initializer for a variable that is not an instance variable declared in the
@@ -1488,6 +1528,26 @@
"Try using a generic function type (returnType 'Function(' parameters ')').");
/**
+ * If a class declaration has a member declaration, the signature of that
+ * member declaration becomes the signature in the interface. It's a
+ * compile-time error if that signature is not a valid override of all
+ * super-interface member signatures with the same name. (Not just the
+ * members of the immediate super-interfaces, but all of them. For
+ * non-covariant parameters, it's sufficient to check just the immediate
+ * super-interfaces).
+ *
+ * Parameters:
+ * 0: the name of the declared member that is not a valid override.
+ * 1: the name of the interface that declares the member.
+ * 2: the type of the declared member in the interface.
+ * 3. the name of the interface with the overridden member.
+ * 4. the type of the overridden member.
+ */
+ static const CompileTimeErrorCode INVALID_OVERRIDE =
+ const CompileTimeErrorCode('INVALID_OVERRIDE',
+ "'{1}.{0}' ('{2}') isn't a valid override of '{3}.{0}' ('{4}').");
+
+ /**
* 12.10 This: It is a compile-time error if this appears in a top-level
* function or variable initializer, in a factory constructor, or in a static
* method or variable initializer, or in the initializer of an instance
@@ -2796,41 +2856,6 @@
"removing the modifier 'sync*' from the function body.");
/**
- * 8.1.1 Inheritance and Overriding: However, if the above rules would cause
- * multiple members <i>m<sub>1</sub>, …, m<sub>k</sub></i> with the
- * same name <i>n</i> that would be inherited (because identically named
- * members existed in several superinterfaces) then at most one member is
- * inherited.
- *
- * If the static types <i>T<sub>1</sub>, …, T<sub>k</sub></i> of the
- * members <i>m<sub>1</sub>, …, m<sub>k</sub></i> are not identical,
- * then there must be a member <i>m<sub>x</sub></i> such that <i>T<sub>x</sub>
- * <: T<sub>i</sub>, 1 <= x <= k</i> for all <i>i, 1 <= i <=
- * k</i>, or a static type warning occurs. The member that is inherited is
- * <i>m<sub>x</sub></i>, if it exists; otherwise:
- * * Let <i>numberOfPositionals</i>(<i>f</i>) denote the number of positional
- * parameters of a function <i>f</i>, and let
- * <i>numberOfRequiredParams</i>(<i>f</i>) denote the number of required
- * parameters of a function <i>f</i>. Furthermore, let <i>s</i> denote the
- * set of all named parameters of the <i>m<sub>1</sub>, …,
- * m<sub>k</sub></i>. Then let
- * * <i>h = max(numberOfPositionals(m<sub>i</sub>)),</i>
- * * <i>r = min(numberOfRequiredParams(m<sub>i</sub>)), for all <i>i</i>, 1 <=
- * i <= k.</i> If <i>r <= h</i> then <i>I</i> has a method named <i>n</i>,
- * with <i>r</i> required parameters of type <b>dynamic</b>, <i>h</i>
- * positional parameters of type <b>dynamic</b>, named parameters <i>s</i>
- * of type <b>dynamic</b> and return type <b>dynamic</b>.
- * * Otherwise none of the members <i>m<sub>1</sub>, …,
- * m<sub>k</sub></i> is inherited.
- */
- static const StaticTypeWarningCode INCONSISTENT_METHOD_INHERITANCE =
- const StaticTypeWarningCode('INCONSISTENT_METHOD_INHERITANCE',
- "Inconsistent declarations of '{0}' are inherited from {1}.",
- correction:
- "Try adjusting the supertypes of this class to remove the "
- "inconsistency.");
-
- /**
* 12.15.1 Ordinary Invocation: It is a static type warning if <i>T</i> does
* not have an accessible (3.2) instance member named <i>m</i>.
*
@@ -3807,158 +3832,6 @@
correction: "Try importing the library that the part is a part of.");
/**
- * 11.1.1 Inheritance and Overriding. Let `I` be the implicit interface of a
- * class `C` declared in library `L`. `I` inherits all members of
- * `inherited(I, L)` and `I` overrides `m'` if `m' ∈ overrides(I, L)`. It is
- * a compile-time error if `m` is a method and `m'` is a getter, or if `m`
- * is a getter and `m'` is a method.
- */
- static const StaticWarningCode
- INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD =
- const StaticWarningCode(
- 'INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD',
- "'{0}' is inherited as a getter and also a method.",
- correction:
- "Try adjusting the supertypes of this class to remove the "
- "inconsistency.");
-
- /**
- * 7.2 Getters: It is a static warning if a getter <i>m1</i> overrides a
- * getter <i>m2</i> and the type of <i>m1</i> is not a subtype of the type of
- * <i>m2</i>.
- *
- * Parameters:
- * 0: the name of the actual return type
- * 1: the name of the expected return type, not assignable to the actual
- * return type
- * 2: the name of the class where the overridden getter is declared
- *
- * See [INVALID_METHOD_OVERRIDE_RETURN_TYPE].
- */
- static const StaticWarningCode INVALID_GETTER_OVERRIDE_RETURN_TYPE =
- const StaticWarningCode(
- 'INVALID_GETTER_OVERRIDE_RETURN_TYPE',
- "The return type '{0}' isn't assignable to '{1}' as required by the "
- "getter it is overriding from '{2}'.",
- correction:
- "Try changing the return types so that they are compatible.");
-
- /**
- * 7.1 Instance Methods: It is a static warning if an instance method
- * <i>m1</i> overrides an instance method <i>m2</i> and the type of <i>m1</i>
- * is not a subtype of the type of <i>m2</i>.
- *
- * Parameters:
- * 0: the name of the actual parameter type
- * 1: the name of the expected parameter type, not assignable to the actual
- * parameter type
- * 2: the name of the class where the overridden method is declared
- */
- static const StaticWarningCode INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE =
- const StaticWarningCode(
- 'INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE',
- "The parameter type '{0}' isn't assignable to '{1}' as required by "
- "the method it is overriding from '{2}'.",
- correction:
- "Try changing the parameter types so that they are compatible.");
-
- /**
- * Generic Method DEP: number of type parameters must match.
- * <https://github.com/leafpetersen/dep-generic-methods/blob/master/proposal.md#function-subtyping>
- *
- * Parameters:
- * 0: the number of type parameters in the method
- * 1: the number of type parameters in the overridden method
- * 2: the name of the class where the overridden method is declared
- */
- static const StaticWarningCode INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS =
- const StaticWarningCode(
- 'INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS',
- "The method has {0} type parameters, but it is overriding a method "
- "with {1} type parameters from '{2}'.",
- correction:
- "Try changing the number of type parameters so that they are the same.");
-
- /**
- * Generic Method DEP: bounds of type parameters must be compatible.
- * <https://github.com/leafpetersen/dep-generic-methods/blob/master/proposal.md#function-subtyping>
- *
- * Parameters:
- * 0: the type parameter name
- * 1: the type parameter bound
- * 2: the overridden type parameter name
- * 3: the overridden type parameter bound
- * 4: the name of the class where the overridden method is declared
- */
- static const StaticWarningCode INVALID_METHOD_OVERRIDE_TYPE_PARAMETER_BOUND =
- const StaticWarningCode(
- 'INVALID_METHOD_OVERRIDE_TYPE_PARAMETER_BOUND',
- "The type parameter '{0}' extends '{1}', but that is stricter than "
- "'{2}' extends '{3}' in the overridden method from '{4}'.",
- correction:
- "Try changing the bounds on the type parameters so that they are compatible.");
-
- /**
- * 7.1 Instance Methods: It is a static warning if an instance method
- * <i>m1</i> overrides an instance method <i>m2</i> and the type of <i>m1</i>
- * is not a subtype of the type of <i>m2</i>.
- *
- * Parameters:
- * 0: the name of the actual parameter type
- * 1: the name of the expected parameter type, not assignable to the actual
- * parameter type
- * 2: the name of the class where the overridden method is declared
- * See [INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE].
- */
- static const StaticWarningCode INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE =
- const StaticWarningCode(
- 'INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE',
- "The parameter type '{0}' isn't assignable to '{1}' as required by "
- "the method it is overriding from '{2}'.",
- correction:
- "Try changing the parameter types so that they are compatible.");
-
- /**
- * 7.1 Instance Methods: It is a static warning if an instance method
- * <i>m1</i> overrides an instance method <i>m2</i> and the type of <i>m1</i>
- * is not a subtype of the type of <i>m2</i>.
- *
- * Parameters:
- * 0: the name of the actual parameter type
- * 1: the name of the expected parameter type, not assignable to the actual
- * parameter type
- * 2: the name of the class where the overridden method is declared
- */
- static const StaticWarningCode INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE =
- const StaticWarningCode(
- 'INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE',
- "The parameter type '{0}' isn't assignable to '{1}' as required by "
- "the method it is overriding from '{2}'.",
- correction:
- "Try changing the parameter types so that they are compatible.");
-
- /**
- * 7.1 Instance Methods: It is a static warning if an instance method
- * <i>m1</i> overrides an instance method <i>m2</i> and the type of <i>m1</i>
- * is not a subtype of the type of <i>m2</i>.
- *
- * Parameters:
- * 0: the name of the actual return type
- * 1: the name of the expected return type, not assignable to the actual
- * return type
- * 2: the name of the class where the overridden method is declared
- *
- * See [INVALID_GETTER_OVERRIDE_RETURN_TYPE].
- */
- static const StaticWarningCode INVALID_METHOD_OVERRIDE_RETURN_TYPE =
- const StaticWarningCode(
- 'INVALID_METHOD_OVERRIDE_RETURN_TYPE',
- "The return type '{0}' isn't assignable to '{1}' as required by the "
- "method it is overriding from '{2}'.",
- correction:
- "Try changing the return types so that they are compatible.");
-
- /**
* 7.1 Instance Methods: It is a static warning if an instance method
* <i>m1</i> overrides an instance member <i>m2</i>, the signature of
* <i>m2</i> explicitly specifies a default value for a formal parameter
@@ -4712,9 +4585,6 @@
static const String _implicitCastCorrection =
"Try adding an explicit cast to '{1}' or improving the type of '{0}'.";
- static const String _invalidOverrideMessage =
- "The type of '{0}.{1}' ('{2}') isn't a subtype of '{3}.{1}' ('{4}').";
-
/**
* This is appended to the end of an error message about implicit dynamic.
*
@@ -4830,23 +4700,6 @@
static const StrongModeCode DYNAMIC_INVOKE = const StrongModeCode(
ErrorType.HINT, 'DYNAMIC_INVOKE', "'{0}' requires a dynamic invoke.");
- static const StrongModeCode INVALID_METHOD_OVERRIDE = const StrongModeCode(
- ErrorType.COMPILE_TIME_ERROR,
- 'INVALID_METHOD_OVERRIDE',
- "Invalid override. $_invalidOverrideMessage");
-
- static const StrongModeCode INVALID_METHOD_OVERRIDE_FROM_BASE =
- const StrongModeCode(
- ErrorType.COMPILE_TIME_ERROR,
- 'INVALID_METHOD_OVERRIDE_FROM_BASE',
- "Base class introduces an invalid override. $_invalidOverrideMessage");
-
- static const StrongModeCode INVALID_METHOD_OVERRIDE_FROM_MIXIN =
- const StrongModeCode(
- ErrorType.COMPILE_TIME_ERROR,
- 'INVALID_METHOD_OVERRIDE_FROM_MIXIN',
- "Mixin introduces an invalid override. $_invalidOverrideMessage");
-
static const StrongModeCode INVALID_FIELD_OVERRIDE = const StrongModeCode(
ErrorType.COMPILE_TIME_ERROR,
'INVALID_FIELD_OVERRIDE',
diff --git a/pkg/analyzer/lib/src/error/inheritance_override.dart b/pkg/analyzer/lib/src/error/inheritance_override.dart
new file mode 100644
index 0000000..fbbb768
--- /dev/null
+++ b/pkg/analyzer/lib/src/error/inheritance_override.dart
@@ -0,0 +1,384 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/analyzer.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/error/listener.dart';
+import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/type_system.dart';
+
+class InheritanceOverrideVerifier {
+ final StrongTypeSystemImpl _typeSystem;
+ final ErrorReporter _reporter;
+
+ /// Cached instance interfaces for [InterfaceType].
+ final Map<InterfaceType, _Interface> _interfaces = {};
+
+ InheritanceOverrideVerifier(this._typeSystem, this._reporter);
+
+ void verifyUnit(CompilationUnit unit) {
+ for (var declaration in unit.declarations) {
+ if (declaration is ClassDeclaration) {
+ _verifyClass(declaration.name,
+ withClause: declaration.withClause, members: declaration.members);
+ } else if (declaration is ClassTypeAlias) {
+ _verifyClass(declaration.name, withClause: declaration.withClause);
+ } else if (declaration is MixinDeclaration) {
+ _verifyClass(declaration.name, members: declaration.members);
+ }
+ }
+ }
+
+ /// Check that the given [member] is a valid override of the corresponding
+ /// instance members in each of [allSuperinterfaces].
+ void _checkDeclaredMember(
+ List<InterfaceType> allSuperinterfaces,
+ AstNode node,
+ ExecutableElement member,
+ ) {
+ if (member == null) return;
+ if (member.isStatic) return;
+
+ var name = member.name;
+ for (var supertype in allSuperinterfaces) {
+ var superMember = _getInstanceMember(supertype, name);
+ if (superMember != null && superMember.isAccessibleIn(member.library)) {
+ // The case when members have different kinds is reported in verifier.
+ if (member.kind != superMember.kind) {
+ continue;
+ }
+
+ if (!_typeSystem.isOverrideSubtypeOf(member.type, superMember.type)) {
+ _reporter.reportErrorForNode(
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ node,
+ [
+ name,
+ member.enclosingElement.name,
+ member.type.displayName,
+ superMember.enclosingElement.name,
+ superMember.type.displayName
+ ],
+ );
+ }
+ }
+ }
+ }
+
+ /// Check that instance members of [type] are valid overrides of the
+ /// corresponding instance members in each of [allSuperinterfaces].
+ void _checkDeclaredMembers(
+ List<InterfaceType> allSuperinterfaces,
+ AstNode node,
+ InterfaceTypeImpl type,
+ ) {
+ for (var method in type.methods) {
+ _checkDeclaredMember(allSuperinterfaces, node, method);
+ }
+ for (var accessor in type.accessors) {
+ _checkDeclaredMember(allSuperinterfaces, node, accessor);
+ }
+ }
+
+ /// Return the instance member given the [name], defined in the [type],
+ /// or `null` if the [type] does not define a member with the [name], or
+ /// if it is not an instance member.
+ ExecutableElement _getInstanceMember(InterfaceType type, String name) {
+ ExecutableElement result;
+ if (name.endsWith('=')) {
+ name = name.substring(0, name.length - 1);
+ result = type.getSetter(name);
+ } else {
+ result = type.getMethod(name) ?? type.getGetter(name);
+ }
+ if (result != null && result.isStatic) {
+ result = null;
+ }
+ return result;
+ }
+
+ /// Return the interface of the given [type], for the [consumerLibrary].
+ _Interface _getInterface(InterfaceType type, LibraryElement consumerLibrary) {
+ if (type == null) return new _Interface({}, []);
+
+ var result = _interfaces[type];
+ if (result != null) return result;
+
+ var map = <String, FunctionType>{};
+ var conflicts = <_Conflict>[];
+ _interfaces[type] = new _Interface(map, conflicts);
+
+ // If a class declaration has a member declaration, the signature of that
+ // member declaration becomes the signature in the interface.
+ {
+ void addTypeMember(ExecutableElement member) {
+ if (member.isAccessibleIn(consumerLibrary) && !member.isStatic) {
+ map[member.name] = member.type;
+ }
+ }
+
+ type.methods.forEach(addTypeMember);
+ type.accessors.forEach(addTypeMember);
+ }
+
+ var inheritedCandidates = <String, List<FunctionType>>{};
+ void addSuperinterfaceMember(String name, FunctionType candidate) {
+ // If name is in the [map], then it is defined in the [type] itself.
+ // Don't consider candidates from direct superinterfaces.
+ // The version defined in the type might be invalid, we check elsewhere.
+ if (map.containsKey(name)) return;
+
+ var candidates = inheritedCandidates[name];
+ if (candidates == null) {
+ candidates = <FunctionType>[];
+ inheritedCandidates[name] = candidates;
+ }
+ candidates.add(candidate);
+ }
+
+ var library = type.element.library;
+ void addSuperinterfaceMembers(InterfaceType superinterface) {
+ _getInterface(superinterface, library)
+ .map
+ .forEach(addSuperinterfaceMember);
+ }
+
+ // Fill candidates for each instance name.
+ addSuperinterfaceMembers(type.superclass);
+ type.superclassConstraints.forEach(addSuperinterfaceMembers);
+ type.mixins.forEach(addSuperinterfaceMembers);
+ type.interfaces.forEach(addSuperinterfaceMembers);
+
+ // If a class declaration does not have a member declaration with a
+ // particular name, but some super-interfaces do have a member with that
+ // name, it's a compile-time error if there is no signature among the
+ // super-interfaces that is a valid override of all the other
+ // super-interface signatures with the same name. That "most specific"
+ // signature becomes the signature of the class's interface.
+ for (var name in inheritedCandidates.keys) {
+ var candidates = inheritedCandidates[name];
+
+ bool allGetters = true;
+ bool allMethods = true;
+ bool allSetters = true;
+ for (var candidate in candidates) {
+ var kind = candidate.element.kind;
+ if (kind != ElementKind.GETTER) {
+ allGetters = false;
+ }
+ if (kind != ElementKind.METHOD) {
+ allMethods = false;
+ }
+ if (kind != ElementKind.SETTER) {
+ allSetters = false;
+ }
+ }
+
+ if (allSetters) {
+ // OK, setters don't conflict with anything.
+ } else if (!(allGetters || allMethods)) {
+ FunctionType getterType;
+ FunctionType methodType;
+ for (var candidate in candidates) {
+ var kind = candidate.element.kind;
+ if (kind == ElementKind.GETTER) {
+ getterType ??= candidate;
+ }
+ if (kind == ElementKind.METHOD) {
+ methodType ??= candidate;
+ }
+ }
+ conflicts.add(new _Conflict(name, candidates, getterType, methodType));
+ continue;
+ }
+
+ FunctionType validOverride;
+ for (var i = 0; i < candidates.length; i++) {
+ validOverride = candidates[i];
+ for (var j = 0; j < candidates.length; j++) {
+ var candidate = candidates[j];
+ if (!_typeSystem.isOverrideSubtypeOf(validOverride, candidate)) {
+ validOverride = null;
+ break;
+ }
+ }
+ if (validOverride != null) {
+ break;
+ }
+ }
+
+ if (validOverride != null) {
+ map[name] = validOverride;
+ } else {
+ conflicts.add(new _Conflict(name, candidates));
+ }
+ }
+
+ return new _Interface(map, conflicts);
+ }
+
+ void _reportInconsistentInheritance(AstNode node, _Conflict conflict) {
+ var name = conflict.name;
+
+ if (conflict.getter != null && conflict.method != null) {
+ _reporter.reportErrorForNode(
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE_GETTER_AND_METHOD,
+ node,
+ [
+ name,
+ conflict.getter.element.enclosingElement.name,
+ conflict.method.element.enclosingElement.name
+ ],
+ );
+ } else {
+ var candidatesStr = conflict.candidates.map((candidate) {
+ var className = candidate.element.enclosingElement.name;
+ return '$className.$name (${candidate.displayName})';
+ }).join(', ');
+
+ _reporter.reportErrorForNode(
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ node,
+ [name, candidatesStr],
+ );
+ }
+ }
+
+ void _verifyClass(SimpleIdentifier classNameNode,
+ {List<ClassMember> members: const [], WithClause withClause}) {
+ ClassElementImpl element = classNameNode.staticElement;
+ LibraryElement library = element.library;
+ InterfaceTypeImpl type = element.type;
+
+ var allSuperinterfaces = <InterfaceType>[];
+
+ // Add all superinterfaces of the direct supertype.
+ if (type.superclass != null) {
+ ClassElementImpl.collectAllSupertypes(
+ allSuperinterfaces, type.superclass, null);
+ }
+
+ // Each mixin in `class C extends S with M0, M1, M2 {}` is equivalent to:
+ // class S&M0 extends S { ...members of M0... }
+ // class S&M1 extends S&M0 { ...members of M1... }
+ // class S&M2 extends S&M1 { ...members of M2... }
+ // class C extends S&M2 { ...members of C... }
+ // So, we need to check members of each mixin against superinterfaces
+ // of `S`, and superinterfaces of all previous mixins.
+ var mixinNodes = withClause?.mixinTypes;
+ var mixinTypes = type.mixins;
+ for (var i = 0; i < mixinTypes.length; i++) {
+ _checkDeclaredMembers(allSuperinterfaces, mixinNodes[i], mixinTypes[i]);
+ ClassElementImpl.collectAllSupertypes(
+ allSuperinterfaces, mixinTypes[i], null);
+ }
+
+ // Add all superinterfaces of the direct class interfaces.
+ for (var interface in type.interfaces) {
+ ClassElementImpl.collectAllSupertypes(
+ allSuperinterfaces, interface, null);
+ }
+
+ // Check the members if the class itself, against all the previously
+ // collected superinterfaces of the supertype, mixins, and interfaces.
+ for (var member in members) {
+ if (member is FieldDeclaration) {
+ var fieldList = member.fields;
+ for (var field in fieldList.variables) {
+ FieldElement fieldElement = field.declaredElement;
+ _checkDeclaredMember(
+ allSuperinterfaces, fieldList, fieldElement.getter);
+ _checkDeclaredMember(
+ allSuperinterfaces, fieldList, fieldElement.setter);
+ }
+ } else if (member is MethodDeclaration) {
+ _checkDeclaredMember(
+ allSuperinterfaces, member, member.declaredElement);
+ }
+ }
+
+ // Compute the interface of the class.
+ var interfaceMembers = _getInterface(type, element.library);
+
+ // Report conflicts between direct superinterfaces of the class.
+ for (var conflict in interfaceMembers.conflicts) {
+ _reportInconsistentInheritance(classNameNode, conflict);
+ }
+
+ // TODO(scheglov) isMixin must be also isAbstract.
+ if (!element.isAbstract && !element.isMixin) {
+ for (var name in interfaceMembers.map.keys) {
+ var concreteElement = type.lookUpInheritedMember(name, library,
+ concrete: true, thisType: true, setter: name.endsWith('='));
+
+ // TODO(scheglov) handle here instead of ErrorVerifier?
+ if (concreteElement == null) {
+ continue;
+ }
+ // TODO(scheglov) Why InterfaceType even returns statics?
+ if (concreteElement.isStatic) {
+ continue;
+ }
+
+ var concreteType = concreteElement.type;
+ var interfaceType = interfaceMembers.map[name];
+
+ // The case when members have different kinds is reported in verifier.
+ if (concreteType.element.kind != interfaceType.element.kind) {
+ continue;
+ }
+
+ // If a class declaration is not abstract, and the interface has a
+ // member declaration named `m`, then:
+ // 1. if the class contains a non-overridden member whose signature is
+ // not a valid override of the interface member signature for `m`,
+ // then it's a compile-time error.
+ // 2. if the class contains no member named `m`, and the class member
+ // for `noSuchMethod` is the one declared in `Object`, then it's a
+ // compile-time error. TODO(scheglov) implement this
+ if (!_typeSystem.isOverrideSubtypeOf(concreteType, interfaceType)) {
+ _reporter.reportErrorForNode(
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ classNameNode,
+ [
+ name,
+ concreteElement.enclosingElement.name,
+ concreteType.displayName,
+ interfaceType.element.enclosingElement.name,
+ interfaceType.displayName
+ ],
+ );
+ }
+ }
+ }
+ }
+}
+
+/// Description of a failure to find a valid override from superinterfaces.
+class _Conflict {
+ /// The name of an instance member for which we failed to find a valid
+ /// override.
+ final String name;
+
+ /// The list of candidates for a valid override for a member [name]. It has
+ /// at least two items, because otherwise the only candidate is always valid.
+ final List<FunctionType> candidates;
+
+ final FunctionType getter;
+ final FunctionType method;
+
+ _Conflict(this.name, this.candidates, [this.getter, this.method]);
+}
+
+/// The instance interface of an [InterfaceType].
+class _Interface {
+ final Map<String, FunctionType> map;
+ final List<_Conflict> conflicts;
+
+ _Interface(this.map, this.conflicts);
+}
diff --git a/pkg/analyzer/lib/src/fasta/error_converter.dart b/pkg/analyzer/lib/src/fasta/error_converter.dart
index eb12686..3c84e61 100644
--- a/pkg/analyzer/lib/src/fasta/error_converter.dart
+++ b/pkg/analyzer/lib/src/fasta/error_converter.dart
@@ -364,7 +364,7 @@
return;
case "INVALID_METHOD_OVERRIDE":
errorReporter?.reportErrorForOffset(
- StrongModeCode.INVALID_METHOD_OVERRIDE, offset, length);
+ CompileTimeErrorCode.INVALID_OVERRIDE, offset, length);
return;
case "INVALID_MODIFIER_ON_SETTER":
_reportByCode(CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER, message,
diff --git a/pkg/analyzer/lib/src/generated/error_verifier.dart b/pkg/analyzer/lib/src/generated/error_verifier.dart
index f36c118..39d92e2 100644
--- a/pkg/analyzer/lib/src/generated/error_verifier.dart
+++ b/pkg/analyzer/lib/src/generated/error_verifier.dart
@@ -4283,7 +4283,7 @@
var superMember = enclosingType.lookUpInheritedMember(
name, _currentLibrary,
concrete: true,
- stopMixinIndex: mixinIndex,
+ startMixinIndex: mixinIndex,
setter: name.endsWith('='));
if (superMember == null) {
_errorReporter.reportErrorForNode(
diff --git a/pkg/analyzer/lib/src/task/dart.dart b/pkg/analyzer/lib/src/task/dart.dart
index 1cedd7a..637d3fa 100644
--- a/pkg/analyzer/lib/src/task/dart.dart
+++ b/pkg/analyzer/lib/src/task/dart.dart
@@ -26,6 +26,7 @@
import 'package:analyzer/src/dart/sdk/patch.dart';
import 'package:analyzer/src/dart/sdk/sdk.dart';
import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/error/inheritance_override.dart';
import 'package:analyzer/src/error/pending_error.dart';
import 'package:analyzer/src/generated/constant.dart';
import 'package:analyzer/src/generated/declaration_resolver.dart';
@@ -5552,6 +5553,14 @@
ConstantVerifier constantVerifier = new ConstantVerifier(
errorReporter, libraryElement, typeProvider, context.declaredVariables);
unit.accept(constantVerifier);
+
+ //
+ // Compute inheritance and override errors.
+ //
+ var inheritanceOverrideVerifier = new InheritanceOverrideVerifier(
+ libraryElement.context.typeSystem, errorReporter);
+ inheritanceOverrideVerifier.verifyUnit(unit);
+
//
// Use the ErrorVerifier to compute errors.
//
diff --git a/pkg/analyzer/lib/src/task/strong/checker.dart b/pkg/analyzer/lib/src/task/strong/checker.dart
index 74f65da..efe990e 100644
--- a/pkg/analyzer/lib/src/task/strong/checker.dart
+++ b/pkg/analyzer/lib/src/task/strong/checker.dart
@@ -95,33 +95,6 @@
return null;
}
-/// Return the field on type corresponding to member, or null if none
-/// exists or the "field" is actually a getter/setter.
-FieldElement _getMemberField(
- InterfaceType type, PropertyAccessorElement member) {
- String memberName = member.name;
- FieldElement field;
- if (member.isGetter) {
- // The subclass member is an explicit getter or a field
- // - lookup the getter on the superclass.
- var getter = type.getGetter(memberName);
- if (getter == null || getter.isStatic) return null;
- field = getter.variable;
- } else if (!member.isSynthetic) {
- // The subclass member is an explicit setter
- // - lookup the setter on the superclass.
- // Note: an implicit (synthetic) setter would have already been flagged on
- // the getter above.
- var setter = type.getSetter(memberName);
- if (setter == null || setter.isStatic) return null;
- field = setter.variable;
- } else {
- return null;
- }
- if (field.isSynthetic) return null;
- return field;
-}
-
/// Looks up the declaration that matches [member] in [type] and returns it's
/// declared type.
FunctionType _getMemberType(InterfaceType type, ExecutableElement member) {
@@ -1276,11 +1249,8 @@
/// applications.
class _OverrideChecker {
final StrongTypeSystemImpl rules;
- final CodeChecker _checker;
- _OverrideChecker(CodeChecker checker)
- : _checker = checker,
- rules = checker.rules;
+ _OverrideChecker(CodeChecker checker) : rules = checker.rules;
void check(Declaration node) {
var element =
@@ -1288,9 +1258,6 @@
if (element.type.isObject) {
return;
}
- _checkSuperOverrides(node, element);
- _checkMixinApplicationOverrides(node, element);
- _checkAllInterfaceOverrides(node, element);
_checkForCovariantGenerics(node, element);
}
@@ -1568,133 +1535,6 @@
return genericSupertypes;
}
- /// Checks that most-derived concrete members on this class correctly override
- /// all reachable interfaces, and reports errors if all interfaces are not
- /// correctly implemented.
- ///
- /// This checks the soundness property: for all interfaces implemented by this
- /// class (including inherited interfaces), we ensure that calls through that
- /// interface will be sound.
- void _checkAllInterfaceOverrides(Declaration node, ClassElement element) {
- var interfaces = _collectInterfacesToCheck(element.type);
- var visitedClasses = new Set<InterfaceType>();
- var visitedMembers = new HashSet<String>();
-
- // Checks all most-derived concrete members on this `type`. We skip over
- // members that are already `visitedMembers`, because they were overridden
- // and we've already checked that member.
- //
- // Because of that, it is important we visit types in the order that they
- // will override members.
- // If checkingMixin is true, then we are checking [type] in a mixin position
- // and hence should consider its own mixins and superclass as abstract.
- void checkType(InterfaceType type, AstNode location,
- {bool checkingMixin: false}) {
- // Skip `Object` because we don't need to check those members here.
- // (because `Object` is the root of everything, it will be checked in
- // _checkSuperOverrides for all classes).
- if (type == null || type.isObject || !visitedClasses.add(type)) return;
-
- // Check `member` against all `interfaces`.
- void checkOverride(ExecutableElement member, [AstNode loc]) {
- if (!visitedMembers.add(member.name)) return;
- for (var interface in interfaces) {
- if (_checkMemberOverride(member, interface, loc ?? location) ==
- false) {
- // Only report one error per member for interfaces.
- // TODO(jmesserly): this is for backwards compatibility. Remove it?
- break;
- }
- }
- }
-
- // When we're checking the class declaration node we started from, we
- // can use a more precise error location for reporting override errors.
- //
- // Otherwise, we'll use the `extends` or `with` clause.
- var isRootClass = identical(location, node);
-
- // Check direct overrides on the class.
- if (isRootClass) {
- _checkClassMembers(node, checkOverride);
- } else {
- _checkTypeMembers(type, checkOverride);
- }
-
- // If we are currently checking a mixin, then its own mixins and
- // superclass are abstract, and we should not check their members.
- // This should only happen when super mixins is enabled, and we
- // don't do proper checking for super mixins (we don't check that
- // the contract implied by the mixin declaration is satisfied by
- // the mixin use), but this prevents us from erroneously
- // rejecting some super mixin patterns.
- // If this is a mixin application (class A = Object with B)
- // however, then we do still need to treat the mixin as concrete.
- if (!checkingMixin || type.element.isMixinApplication) {
- // Check mixin members against interfaces.
- //
- // We visit mixins in reverse order to reflect how they override
- // eachother.
- for (int i = type.mixins.length - 1; i >= 0; i--) {
- checkType(type.mixins[i],
- isRootClass ? _withClause(node).mixinTypes[i] : location,
- checkingMixin: true);
- }
-
- // Check members on the superclass.
- checkType(type.superclass,
- isRootClass ? _extendsErrorLocation(node) : location,
- checkingMixin: checkingMixin);
- }
- }
-
- checkType(element.type, node);
- }
-
- /// Gets the set of all interfaces on [type] that should be checked to see
- /// if type's members are overriding them correctly.
- ///
- /// In particular, we need to check these overrides for the definitions in
- /// the class itself and each its superclasses (and mixins).
- /// If a superclass (or mixin) is concrete, then we can skip its transitive
- /// interfaces, but if it is abstract we must check them. For example, in:
- ///
- /// B extends C implements G
- /// A extends B with E, F implements H, I
- ///
- /// we need to check the following interfaces:
- ///
- /// C against G, H, and I
- /// B against G, H, and I
- /// E against H and I // no check against G because B is a concrete class
- /// F against H and I
- /// A against H and I
- Set<InterfaceType> _collectInterfacesToCheck(InterfaceType type) {
- var interfaces = new Set<InterfaceType>();
- void collectInterfaces(InterfaceType t) {
- if (t == null || t.isObject) return;
- if (!interfaces.add(t)) return;
- collectInterfaces(t.superclass);
- t.mixins.forEach(collectInterfaces);
- t.interfaces.forEach(collectInterfaces);
- }
-
- // Check all interfaces reachable from the `implements` clause in the
- // current class against definitions here and in superclasses.
- type.interfaces.forEach(collectInterfaces);
-
- // Also collect interfaces from any abstract mixins or superclasses.
- //
- // For a concrete mixin/superclass, we'll check that we override the
- // concrete members in _checkSuperOverrides and
- // _checkMixinApplicationOverrides. But for abstract classes, we need to
- // consider any abstract members it got from its interfaces.
- for (var s in _getSuperclasses(type, (t) => t.element.isAbstract)) {
- s.interfaces.forEach(collectInterfaces);
- }
- return interfaces;
- }
-
/// Visits each member on the class [node] and calls [checkMember] with the
/// corresponding instance element and AST node (for error reporting).
///
@@ -1739,196 +1579,11 @@
type.accessors.forEach(checkHelper);
}
- /// Check overrides from mixin applications themselves. For example, in:
- ///
- /// A extends B with E, F
- ///
- /// we check:
- ///
- /// B & E against B (equivalently how E overrides B)
- /// B & E & F against B & E (equivalently how F overrides both B and E)
- void _checkMixinApplicationOverrides(Declaration node, ClassElement element) {
- var superclass = element.type.superclass;
- var mixins = element.type.mixins;
-
- // Check overrides from applying mixins
- for (int i = 0; i < mixins.length; i++) {
- var current = mixins[i];
- var location = _withClause(node).mixinTypes[i];
- var superclasses = mixins.sublist(0, i).reversed.toList()
- ..add(superclass);
-
- _checkTypeMembers(current, (m) {
- for (var s in superclasses) {
- if (_checkConcreteMemberOverride(m, s, location)) break;
- }
- });
- }
- }
-
- /// Gets the member corresponding to [member] on [type], and returns `null`
- /// if no member was found, or a boolean value to indicate whether the
- /// override is valid.
- ///
- /// The [location] is a node where the error is reported. For example, a
- /// bad override of a method in a class with respect to its superclass is
- /// reported directly at the method declaration. However, invalid overrides
- /// from base classes to interfaces, mixins to the base they are applied to,
- /// or mixins to interfaces are reported at the class declaration, since the
- /// base class or members on their own were not incorrect, only combining them
- /// with the interface was problematic. For example, these are example error
- /// locations in these cases:
- ///
- /// error: base class introduces an invalid override. The type of B.foo is
- /// not a subtype of E.foo:
- /// class A extends B implements E { ... }
- /// ^^^^^^^^^
- ///
- /// error: mixin introduces an invalid override. The type of C.foo is not
- /// a subtype of E.foo:
- /// class A extends B with C implements E { ... }
- /// ^
- ///
- /// When checking for overrides from a type and it's super types, [node] is
- /// the AST node that defines [member]. This is used to determine whether the
- /// type of the element could be inferred from the types in the super classes.
- bool _checkMemberOverride(
- ExecutableElement member, InterfaceType type, AstNode location) {
- assert(!member.isStatic);
-
- FunctionType subType = _elementType(member);
- FunctionType baseType = _getMemberType(type, member);
- if (baseType == null) return null;
-
- if (!rules.isOverrideSubtypeOf(subType, baseType)) {
- ErrorCode errorCode;
- var parent = location?.parent;
- if (location is ExtendsClause ||
- parent is ClassTypeAlias && parent.superclass == location) {
- errorCode = StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_BASE;
- } else if (parent is WithClause) {
- errorCode = StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_MIXIN;
- } else {
- errorCode = StrongModeCode.INVALID_METHOD_OVERRIDE;
- }
-
- _checker._recordMessage(location, errorCode,
- [member.enclosingElement.name, member.name, subType, type, baseType]);
- return false;
- }
- return true;
- }
-
- /// Checks that a member override from a superclass (i.e. a concrete member)
- /// is correct, reporting an error if needed, and returns `true` if we should
- /// keep searching up the superclass chain.
- bool _checkConcreteMemberOverride(
- ExecutableElement member, InterfaceType type, AstNode location) {
- _checkFieldOverride(member, type, location);
- // Stop if a member was found, and we have no covariant parameters.
- // If we have covariant parameters, we need to keep searching.
- return _checkMemberOverride(member, type, location) != null &&
- member.parameters.every((p) => !p.isCovariant);
- }
-
- void _checkFieldOverride(
- Element member, InterfaceType type, AstNode location) {
- if (member is PropertyAccessorElement) {
- // Disallow overriding a non-virtual field.
- var field = _getMemberField(type, member);
- if (field != null && !field.isVirtual) {
- FunctionType subType = _elementType(member);
- FunctionType baseType = _getMemberType(type, member);
- _checker._recordMessage(
- location, StrongModeCode.INVALID_FIELD_OVERRIDE, [
- member.enclosingElement.name,
- member.name,
- subType,
- type,
- baseType
- ]);
- }
- }
- }
-
- /// Check overrides between a class and its superclasses and mixins. For
- /// example, in:
- ///
- /// A extends B with E, F
- ///
- /// we check A against B, B super classes, E, and F.
- ///
- /// Internally we avoid reporting errors twice and we visit classes bottom up
- /// to ensure we report the most immediate invalid override first. For
- /// example, in the following code we'll report that `Test` has an invalid
- /// override with respect to `Parent` (as opposed to an invalid override with
- /// respect to `Grandparent`):
- ///
- /// class Grandparent {
- /// m(A a) {}
- /// }
- /// class Parent extends Grandparent {
- /// m(A a) {}
- /// }
- /// class Test extends Parent {
- /// m(B a) {} // invalid override
- /// }
- void _checkSuperOverrides(Declaration node, ClassElement element) {
- var superclasses = _getSuperclasses(element.type);
- _checkClassMembers(node, (member, loc) {
- for (var s in superclasses) {
- if (_checkConcreteMemberOverride(member, s, loc)) break;
- }
- });
- }
-
- /// Collects all superclasses of [type], including any mixin application
- /// classes.
- ///
- /// The search can be pruned by passing a [visitSuperclasses] function and
- /// having it return `false` for types that should not be further explored.
- Iterable<InterfaceType> _getSuperclasses(InterfaceType type,
- [bool visitSuperclasses(InterfaceType t)]) {
- var superclasses = new Set<InterfaceType>();
- visit(InterfaceType t) {
- if ((visitSuperclasses == null || visitSuperclasses(t)) &&
- superclasses.add(t)) {
- t.mixins.reversed.forEach(visit);
- var s = t.superclass;
- if (s != null && !s.isObject) visit(s);
- }
- }
-
- type.mixins.reversed.forEach(visit);
- var s = type.superclass;
- if (s != null && !s.isObject) visit(s);
-
- // Make sure we record Object last, and not when we visit our mixins.
- if (!type.isObject) visit(rules.typeProvider.objectType);
- return superclasses;
- }
-
/// If node is a [ClassDeclaration] returns its members, otherwise if node is
/// a [ClassTypeAlias] this returns an empty list.
Iterable<ClassMember> _classMembers(Declaration node) {
return node is ClassDeclaration ? node.members : [];
}
-
- /// If node is a [ClassDeclaration] returns its members, otherwise if node is
- /// a [ClassTypeAlias] this returns an empty list.
- AstNode _extendsErrorLocation(Declaration node) {
- return node is ClassDeclaration
- ? node.extendsClause
- : (node as ClassTypeAlias).superclass;
- }
-
- /// If node is a [ClassDeclaration] returns its members, otherwise if node is
- /// a [ClassTypeAlias] this returns an empty list.
- WithClause _withClause(Declaration node) {
- return node is ClassDeclaration
- ? node.withClause
- : (node as ClassTypeAlias).withClause;
- }
}
class _TopLevelInitializerValidator extends RecursiveAstVisitor<Null> {
diff --git a/pkg/analyzer/test/generated/compile_time_error_code_test.dart b/pkg/analyzer/test/generated/compile_time_error_code_test.dart
index 724f3b8..dbfb8a2 100644
--- a/pkg/analyzer/test/generated/compile_time_error_code_test.dart
+++ b/pkg/analyzer/test/generated/compile_time_error_code_test.dart
@@ -2649,10 +2649,20 @@
test_implementsDisallowedClass_class_String_num() async {
Source source = addSource("class A implements String, num {}");
await computeAnalysisResult(source);
- assertErrors(source, [
- CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS,
- CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS
- ]);
+ if (enableNewAnalysisDriver) {
+ assertErrors(source, [
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS,
+ CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS
+ ]);
+ } else {
+ assertErrors(source, [
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS,
+ CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS
+ ]);
+ }
verify([source]);
}
@@ -2722,10 +2732,20 @@
class M {}
class C = A with M implements String, num;''');
await computeAnalysisResult(source);
- assertErrors(source, [
- CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS,
- CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS
- ]);
+ if (enableNewAnalysisDriver) {
+ assertErrors(source, [
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS,
+ CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS
+ ]);
+ } else {
+ assertErrors(source, [
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS,
+ CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS
+ ]);
+ }
verify([source]);
}
@@ -4231,14 +4251,18 @@
class A {}
class C = A with String, num;''');
await computeAnalysisResult(source);
- if (previewDart2) {
+ if (enableNewAnalysisDriver) {
assertErrors(source, [
- StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_MIXIN,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ CompileTimeErrorCode.INVALID_OVERRIDE,
CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS,
CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS
]);
} else {
assertErrors(source, [
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
+ CompileTimeErrorCode.INVALID_OVERRIDE,
CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS,
CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS
]);
diff --git a/pkg/analyzer/test/generated/non_error_resolver_test.dart b/pkg/analyzer/test/generated/non_error_resolver_test.dart
index d224d7f..463e686 100644
--- a/pkg/analyzer/test/generated/non_error_resolver_test.dart
+++ b/pkg/analyzer/test/generated/non_error_resolver_test.dart
@@ -4458,7 +4458,12 @@
class C {}
class B extends A with C {}''');
await computeAnalysisResult(source);
- assertNoErrors(source);
+ if (previewDart2) {
+ assertErrors(
+ source,
+ [CompileTimeErrorCode.INVALID_OVERRIDE],
+ );
+ }
verify([source]);
}
diff --git a/pkg/analyzer/test/generated/non_hint_code_test.dart b/pkg/analyzer/test/generated/non_hint_code_test.dart
index a687345..208b637 100644
--- a/pkg/analyzer/test/generated/non_hint_code_test.dart
+++ b/pkg/analyzer/test/generated/non_hint_code_test.dart
@@ -658,7 +658,10 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(
+ source,
+ [CompileTimeErrorCode.INVALID_OVERRIDE],
+ );
} else {
assertNoErrors(source);
}
@@ -682,7 +685,10 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(
+ source,
+ [CompileTimeErrorCode.INVALID_OVERRIDE],
+ );
} else {
assertNoErrors(source);
}
diff --git a/pkg/analyzer/test/generated/static_warning_code_test.dart b/pkg/analyzer/test/generated/static_warning_code_test.dart
index 5003da0..825e0fb 100644
--- a/pkg/analyzer/test/generated/static_warning_code_test.dart
+++ b/pkg/analyzer/test/generated/static_warning_code_test.dart
@@ -1859,12 +1859,7 @@
String get g { return 'a'; }
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -1877,17 +1872,10 @@
int f;
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [
- StrongModeCode.INVALID_METHOD_OVERRIDE,
- StrongModeCode.INVALID_METHOD_OVERRIDE
- ]);
- } else {
- assertErrors(source, [
- StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE,
- StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE
- ]);
- }
+ assertErrors(source, [
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE
+ ]);
verify([source]);
}
@@ -1905,12 +1893,10 @@
String get getter => null;
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE]);
- }
+ assertErrors(source, [
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ ]);
verify([source]);
}
@@ -1926,12 +1912,10 @@
double get g => null;
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE]);
- }
+ assertErrors(source, [
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE
+ ]);
verify([source]);
}
@@ -1944,12 +1928,7 @@
m({String a}) {}
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -1962,12 +1941,7 @@
m(String a) {}
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(source,
- [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -1980,12 +1954,7 @@
m(String a) {}
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(source,
- [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -2001,15 +1970,10 @@
m(double d) {}
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [
- StrongModeCode.INVALID_METHOD_OVERRIDE,
- StrongModeCode.INVALID_METHOD_OVERRIDE
- ]);
- } else {
- assertErrors(source,
- [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
- }
+ assertErrors(source, [
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE
+ ]);
verify([source]);
}
@@ -2026,12 +1990,10 @@
m(String n) {}
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(source,
- [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
- }
+ assertErrors(source, [
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE
+ ]);
verify([source]);
}
@@ -2048,12 +2010,10 @@
m(double d) {}
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(source,
- [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]);
- }
+ assertErrors(source, [
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE
+ ]);
verify([source]);
}
@@ -2066,12 +2026,7 @@
m([String a]) {}
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(source,
- [StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -2088,12 +2043,10 @@
m([String n]) {}
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(source,
- [StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE]);
- }
+ assertErrors(source, [
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE
+ ]);
verify([source]);
}
@@ -2106,12 +2059,7 @@
String m() { return 'a'; }
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -2126,12 +2074,7 @@
String m() { return 'a'; }
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -2144,12 +2087,7 @@
String m() { return 'a'; }
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -2162,12 +2100,7 @@
String m() { return 'a'; }
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -2182,12 +2115,7 @@
String m() { return 'a'; }
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -2204,12 +2132,10 @@
String m() => '';
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
- }
+ assertErrors(source, [
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE
+ ]);
verify([source]);
}
@@ -2222,12 +2148,7 @@
void m() {}
}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
- } else {
- assertErrors(
- source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -2393,7 +2314,7 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
} else {
assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_NAMED]);
}
@@ -2410,7 +2331,7 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
} else {
assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_NAMED]);
}
@@ -2427,7 +2348,7 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
} else {
assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
}
@@ -2444,7 +2365,7 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
} else {
assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
}
@@ -2461,7 +2382,7 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
} else {
assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
}
@@ -2478,7 +2399,7 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
} else {
assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_REQUIRED]);
}
@@ -2495,7 +2416,7 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
} else {
assertErrors(source,
[StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
@@ -2518,9 +2439,8 @@
await computeAnalysisResult(source);
if (previewDart2) {
assertErrors(source, [
- StrongModeCode.INVALID_METHOD_OVERRIDE,
- StrongModeCode.INVALID_METHOD_OVERRIDE,
- StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_BASE
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE,
]);
} else {
assertErrors(source,
@@ -2544,7 +2464,10 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE
+ ]);
} else {
assertErrors(source,
[StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
@@ -2565,7 +2488,10 @@
}''');
await computeAnalysisResult(source);
if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [
+ CompileTimeErrorCode.INVALID_OVERRIDE,
+ CompileTimeErrorCode.INVALID_OVERRIDE
+ ]);
} else {
assertErrors(source,
[StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]);
@@ -2923,12 +2849,7 @@
}
class E extends C implements D {}''');
await computeAnalysisResult(source);
- if (previewDart2) {
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_BASE]);
- } else {
- assertErrors(source,
- [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
- }
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
diff --git a/pkg/analyzer/test/generated/strong_mode_test.dart b/pkg/analyzer/test/generated/strong_mode_test.dart
index 0456a6f..d302e2f 100644
--- a/pkg/analyzer/test/generated/strong_mode_test.dart
+++ b/pkg/analyzer/test/generated/strong_mode_test.dart
@@ -3460,7 +3460,7 @@
T f<T extends B>(T x) => null;
}''');
await computeAnalysisResult(source);
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -3475,7 +3475,7 @@
T f<T extends A>(T x) => null;
}''');
await computeAnalysisResult(source);
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -3488,7 +3488,7 @@
String f<S>(S x) => null;
}''');
await computeAnalysisResult(source);
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
@@ -3501,7 +3501,7 @@
S f<T, S>(T x) => null;
}''');
await computeAnalysisResult(source);
- assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+ assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
verify([source]);
}
diff --git a/pkg/analyzer/test/src/dart/resolution/class_test.dart b/pkg/analyzer/test/src/dart/resolution/class_test.dart
index e617b68..1cac15e 100644
--- a/pkg/analyzer/test/src/dart/resolution/class_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/class_test.dart
@@ -1291,7 +1291,7 @@
expect(method.isStatic, isTrue);
}
- test_inconsistentMethodInheritance_parameterType() async {
+ test_inconsistentInheritance_parameterType() async {
addTestFile(r'''
abstract class A {
x(int i);
@@ -1303,11 +1303,11 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
]);
}
- test_inconsistentMethodInheritance_requiredParameters() async {
+ test_inconsistentInheritance_requiredParameters() async {
addTestFile(r'''
abstract class A {
x();
@@ -1319,11 +1319,11 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
]);
}
- test_inconsistentMethodInheritance_returnType() async {
+ test_inconsistentInheritance_returnType() async {
addTestFile(r'''
abstract class A {
int x();
@@ -1335,11 +1335,11 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
]);
}
- test_inconsistentMethodInheritanceGetterAndMethod_getter_method() async {
+ test_inconsistentInheritanceGetterAndMethod_getter_method() async {
addTestFile(r'''
abstract class A {
int get x;
@@ -1351,11 +1351,11 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE_GETTER_AND_METHOD,
]);
}
- test_inconsistentMethodInheritanceGetterAndMethod_method_getter() async {
+ test_inconsistentInheritanceGetterAndMethod_method_getter() async {
addTestFile(r'''
abstract class A {
int x();
@@ -1367,7 +1367,7 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE_GETTER_AND_METHOD,
]);
}
diff --git a/pkg/analyzer/test/src/dart/resolution/mixin_test.dart b/pkg/analyzer/test/src/dart/resolution/mixin_test.dart
index 0375fc2..d1e8e1f 100644
--- a/pkg/analyzer/test/src/dart/resolution/mixin_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/mixin_test.dart
@@ -1419,7 +1419,71 @@
assertTypeName(bRef, findElement.class_('B'), 'B');
}
- test_inconsistentMethodInheritance_implements_parameterType() async {
+ test_inconsistentInheritanceGetterAndMethod_implements_getter_method() async {
+ addTestFile(r'''
+abstract class A {
+ int get x;
+}
+abstract class B {
+ int x();
+}
+mixin M implements A, B {}
+''');
+ await resolveTestFile();
+ assertTestErrors([
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE_GETTER_AND_METHOD,
+ ]);
+ }
+
+ test_inconsistentInheritanceGetterAndMethod_implements_method_getter() async {
+ addTestFile(r'''
+abstract class A {
+ int x();
+}
+abstract class B {
+ int get x;
+}
+mixin M implements A, B {}
+''');
+ await resolveTestFile();
+ assertTestErrors([
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE_GETTER_AND_METHOD,
+ ]);
+ }
+
+ test_inconsistentInheritanceGetterAndMethod_on_getter_method() async {
+ addTestFile(r'''
+abstract class A {
+ int get x;
+}
+abstract class B {
+ int x();
+}
+mixin M implements A, B {}
+''');
+ await resolveTestFile();
+ assertTestErrors([
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE_GETTER_AND_METHOD,
+ ]);
+ }
+
+ test_inconsistentInheritanceGetterAndMethod_on_method_getter() async {
+ addTestFile(r'''
+abstract class A {
+ int x();
+}
+abstract class B {
+ int get x;
+}
+mixin M implements A, B {}
+''');
+ await resolveTestFile();
+ assertTestErrors([
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE_GETTER_AND_METHOD,
+ ]);
+ }
+
+ test_inconsistentInheritance_implements_parameterType() async {
addTestFile(r'''
abstract class A {
x(int i);
@@ -1431,11 +1495,11 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
]);
}
- test_inconsistentMethodInheritance_implements_requiredParameters() async {
+ test_inconsistentInheritance_implements_requiredParameters() async {
addTestFile(r'''
abstract class A {
x();
@@ -1447,11 +1511,11 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
]);
}
- test_inconsistentMethodInheritance_implements_returnType() async {
+ test_inconsistentInheritance_implements_returnType() async {
addTestFile(r'''
abstract class A {
int x();
@@ -1463,11 +1527,11 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
]);
}
- test_inconsistentMethodInheritance_on_parameterType() async {
+ test_inconsistentInheritance_on_parameterType() async {
addTestFile(r'''
abstract class A {
x(int i);
@@ -1479,11 +1543,11 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
]);
}
- test_inconsistentMethodInheritance_on_requiredParameters() async {
+ test_inconsistentInheritance_on_requiredParameters() async {
addTestFile(r'''
abstract class A {
x();
@@ -1495,11 +1559,11 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
]);
}
- test_inconsistentMethodInheritance_on_returnType() async {
+ test_inconsistentInheritance_on_returnType() async {
addTestFile(r'''
abstract class A {
int x();
@@ -1511,71 +1575,7 @@
''');
await resolveTestFile();
assertTestErrors([
- StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
- ]);
- }
-
- test_inconsistentMethodInheritanceGetterAndMethod_implements_getter_method() async {
- addTestFile(r'''
-abstract class A {
- int get x;
-}
-abstract class B {
- int x();
-}
-mixin M implements A, B {}
-''');
- await resolveTestFile();
- assertTestErrors([
- StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
- ]);
- }
-
- test_inconsistentMethodInheritanceGetterAndMethod_implements_method_getter() async {
- addTestFile(r'''
-abstract class A {
- int x();
-}
-abstract class B {
- int get x;
-}
-mixin M implements A, B {}
-''');
- await resolveTestFile();
- assertTestErrors([
- StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
- ]);
- }
-
- test_inconsistentMethodInheritanceGetterAndMethod_on_getter_method() async {
- addTestFile(r'''
-abstract class A {
- int get x;
-}
-abstract class B {
- int x();
-}
-mixin M implements A, B {}
-''');
- await resolveTestFile();
- assertTestErrors([
- StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
- ]);
- }
-
- test_inconsistentMethodInheritanceGetterAndMethod_on_method_getter() async {
- addTestFile(r'''
-abstract class A {
- int x();
-}
-abstract class B {
- int get x;
-}
-mixin M implements A, B {}
-''');
- await resolveTestFile();
- assertTestErrors([
- StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
+ CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
]);
}
diff --git a/pkg/analyzer/test/src/summary/top_level_inference_test.dart b/pkg/analyzer/test/src/summary/top_level_inference_test.dart
index 939596c..65921c7 100644
--- a/pkg/analyzer/test/src/summary/top_level_inference_test.dart
+++ b/pkg/analyzer/test/src/summary/top_level_inference_test.dart
@@ -332,7 +332,7 @@
String aaa;
}
class C implements A, B {
- /*error:INVALID_METHOD_OVERRIDE*/var aaa;
+ /*error:INVALID_OVERRIDE,error:INVALID_OVERRIDE*/var aaa;
}
''';
await checkFile(content);
diff --git a/pkg/analyzer/test/src/task/options_test.dart b/pkg/analyzer/test/src/task/options_test.dart
index e2a8682..e00db4f 100644
--- a/pkg/analyzer/test/src/task/options_test.dart
+++ b/pkg/analyzer/test/src/task/options_test.dart
@@ -227,9 +227,6 @@
removeCode(StrongModeCode.INVALID_SUPER_INVOCATION);
removeCode(StrongModeCode.NON_GROUND_TYPE_CHECK_INFO);
removeCode(StrongModeCode.DYNAMIC_INVOKE);
- removeCode(StrongModeCode.INVALID_METHOD_OVERRIDE);
- removeCode(StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_BASE);
- removeCode(StrongModeCode.INVALID_METHOD_OVERRIDE_FROM_MIXIN);
removeCode(StrongModeCode.INVALID_FIELD_OVERRIDE);
removeCode(StrongModeCode.IMPLICIT_DYNAMIC_PARAMETER);
removeCode(StrongModeCode.IMPLICIT_DYNAMIC_RETURN);
diff --git a/pkg/analyzer/test/src/task/strong/checker_test.dart b/pkg/analyzer/test/src/task/strong/checker_test.dart
index 994a8bd..0bce85a 100644
--- a/pkg/analyzer/test/src/task/strong/checker_test.dart
+++ b/pkg/analyzer/test/src/task/strong/checker_test.dart
@@ -172,7 +172,7 @@
abstract class Base implements I1 {}
class T1 extends Base {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
@@ -190,10 +190,7 @@
implements I1 {}
class T1 extends Base {
- // not reported technically because if the class is concrete,
- // it should implement all its interfaces and hence it is
- // sufficient to check overrides against it.
- m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
@@ -209,7 +206,7 @@
abstract class I2 implements I1 {}
class T1 implements I2 {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
@@ -225,7 +222,7 @@
abstract class I2 extends Object with M1 {}
class T1 implements I2 {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
@@ -241,7 +238,7 @@
abstract class I2 extends I1 {}
class T1 implements I2 {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
@@ -546,20 +543,21 @@
class G extends E implements D {}
class D_error extends C {
- /*error:INVALID_METHOD_OVERRIDE*/int f(int x) => x;
+ /*error:INVALID_OVERRIDE*/int f(int x) => x;
}
class E_error extends D {
- /*error:INVALID_METHOD_OVERRIDE*/int f(@checked double x) => 0;
+ /*error:INVALID_OVERRIDE*/int f(@checked double x) => 0;
}
class F_error extends E {
- /*error:INVALID_METHOD_OVERRIDE*/int f(@checked double x) => 0;
+ /*error:INVALID_OVERRIDE*/int f(@checked double x) => 0;
}
class G_error extends E implements D {
- /*error:INVALID_METHOD_OVERRIDE*/int f(@checked double x) => 0;
+ /*error:INVALID_OVERRIDE*/int f(@checked double x) => 0;
}
''');
}
+ @failingTest
test_covariantOverride_fields() async {
_addMetaLibrary();
await checkFile(r'''
@@ -579,7 +577,7 @@
@virtual int foo;
}
class E extends D {
- @virtual /*error:INVALID_METHOD_OVERRIDE*/num foo;
+ @virtual num foo;
}
''');
}
@@ -628,16 +626,16 @@
class G extends E implements D {}
class D_error extends C {
- /*error:INVALID_METHOD_OVERRIDE*/int f(String x) => 0;
+ /*error:INVALID_OVERRIDE*/int f(String x) => 0;
}
class E_error extends D {
- /*error:INVALID_METHOD_OVERRIDE*/int f(double x) => 0;
+ /*error:INVALID_OVERRIDE*/int f(double x) => 0;
}
class F_error extends E {
- /*error:INVALID_METHOD_OVERRIDE*/int f(double x) => 0;
+ /*error:INVALID_OVERRIDE*/int f(double x) => 0;
}
class G_error extends E implements D {
- /*error:INVALID_METHOD_OVERRIDE*/int f(double x) => 0;
+ /*error:INVALID_OVERRIDE*/int f(double x) => 0;
}
''');
}
@@ -730,17 +728,17 @@
}
class Child extends Base {
- /*error:INVALID_METHOD_OVERRIDE*/A f1; // invalid for getter
- /*error:INVALID_METHOD_OVERRIDE*/C f2; // invalid for setter
+ /*error:INVALID_OVERRIDE*/A f1; // invalid for getter
+ /*error:INVALID_OVERRIDE*/C f2; // invalid for setter
var f3;
- /*error:INVALID_METHOD_OVERRIDE*/dynamic f4;
+ /*error:INVALID_OVERRIDE*/dynamic f4;
}
class Child2 implements Base {
- /*error:INVALID_METHOD_OVERRIDE*/A f1; // invalid for getter
- /*error:INVALID_METHOD_OVERRIDE*/C f2; // invalid for setter
+ /*error:INVALID_OVERRIDE*/A f1; // invalid for getter
+ /*error:INVALID_OVERRIDE*/C f2; // invalid for setter
var f3;
- /*error:INVALID_METHOD_OVERRIDE*/dynamic f4;
+ /*error:INVALID_OVERRIDE*/dynamic f4;
}
''');
}
@@ -759,17 +757,17 @@
}
class Child extends Base {
- /*error:INVALID_METHOD_OVERRIDE*/A get f1 => null;
+ /*error:INVALID_OVERRIDE*/A get f1 => null;
C get f2 => null;
get f3 => null;
- /*error:INVALID_METHOD_OVERRIDE*/dynamic get f4 => null;
+ /*error:INVALID_OVERRIDE*/dynamic get f4 => null;
}
class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR*/Child2 implements Base {
- /*error:INVALID_METHOD_OVERRIDE*/A get f1 => null;
+ /*error:INVALID_OVERRIDE*/A get f1 => null;
C get f2 => null;
get f3 => null;
- /*error:INVALID_METHOD_OVERRIDE*/dynamic get f4 => null;
+ /*error:INVALID_OVERRIDE*/dynamic get f4 => null;
}
''');
}
@@ -783,12 +781,12 @@
}
class G extends F {
- /*error:INVALID_METHOD_OVERRIDE*/final ToVoid<int> f = null;
+ /*error:INVALID_OVERRIDE*/final ToVoid<int> f = null;
final ToVoid<dynamic> g = null;
}
class H implements F {
- /*error:INVALID_METHOD_OVERRIDE*/final ToVoid<int> f = null;
+ /*error:INVALID_OVERRIDE*/final ToVoid<int> f = null;
final ToVoid<dynamic> g = null;
}
''');
@@ -846,7 +844,7 @@
B get f5 => null;
void set f1(A value) {}
- /*error:INVALID_METHOD_OVERRIDE*/void set f2(C value) {}
+ /*error:INVALID_OVERRIDE*/void set f2(C value) {}
void set f3(value) {}
void set f4(dynamic value) {}
set f5(B value) {}
@@ -860,7 +858,7 @@
B get f5 => null;
void set f1(A value) {}
- /*error:INVALID_METHOD_OVERRIDE*/void set f2(C value) {}
+ /*error:INVALID_OVERRIDE*/void set f2(C value) {}
void set f3(value) {}
void set f4(dynamic value) {}
set f5(B value) {}
@@ -1966,7 +1964,7 @@
}
class Derived<S extends A> extends Base<B> {
- /*error:INVALID_METHOD_OVERRIDE*/S foo() => null;
+ /*error:INVALID_OVERRIDE*/S foo() => null;
}
class Derived2<S extends B> extends Base<B> {
@@ -2074,10 +2072,10 @@
}
class Child extends Base {
- /*error:INVALID_METHOD_OVERRIDE*/A get f1 => null;
+ /*error:INVALID_OVERRIDE*/A get f1 => null;
C get f2 => null;
get f3 => null;
- /*error:INVALID_METHOD_OVERRIDE*/dynamic get f4 => null;
+ /*error:INVALID_OVERRIDE*/dynamic get f4 => null;
}
''');
}
@@ -2092,12 +2090,12 @@
}
class G extends F {
- /*error:INVALID_METHOD_OVERRIDE*/ToVoid<int> get f => null;
+ /*error:INVALID_OVERRIDE*/ToVoid<int> get f => null;
ToVoid<dynamic> get g => null;
}
class H implements F {
- /*error:INVALID_METHOD_OVERRIDE*/ToVoid<int> get f => null;
+ /*error:INVALID_OVERRIDE*/ToVoid<int> get f => null;
ToVoid<dynamic> get g => null;
}
''');
@@ -2552,7 +2550,7 @@
set x(Object y) {}
}
class D implements B, C {
- /*error:INVALID_METHOD_OVERRIDE*/int x;
+ /*error:INVALID_OVERRIDE*/int x;
}
''');
}
@@ -2566,13 +2564,13 @@
abstract class M implements I {}
class C extends Object with M {
- /*error:INVALID_METHOD_OVERRIDE*/String x;
+ /*error:INVALID_OVERRIDE*/String x;
}
abstract class M2 = Object with M;
class C2 extends Object with M2 {
- /*error:INVALID_METHOD_OVERRIDE*/String x;
+ /*error:INVALID_OVERRIDE*/String x;
}
''');
}
@@ -2603,13 +2601,13 @@
abstract class M<E> implements I<E> {}
class C extends Object with M<int> {
- /*error:INVALID_METHOD_OVERRIDE*/String x;
+ /*error:INVALID_OVERRIDE*/String x;
}
abstract class D extends Object with M<num> {}
/*error:CONFLICTING_GENERIC_INTERFACES*/
/*error:CONFLICTING_GENERIC_INTERFACES*/class E extends D with M<int> {
- /*error:INVALID_METHOD_OVERRIDE*/int x;
+ /*error:INVALID_OVERRIDE*/int x;
}
/*error:CONFLICTING_GENERIC_INTERFACES*/
/*error:CONFLICTING_GENERIC_INTERFACES*/class F extends D with M<int> {
@@ -2631,8 +2629,8 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
- /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base implements I {}
+class /*error:INCONSISTENT_INHERITANCE*/T1
+ extends Base implements I {}
''');
}
@@ -2646,37 +2644,37 @@
}
class T1 extends Base {
- /*error:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE,error:INVALID_METHOD_OVERRIDE*/B get f => null;
+ /*error:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE,error:INVALID_OVERRIDE*/B get f => null;
}
class T2 extends Base {
- /*error:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE,error:INVALID_METHOD_OVERRIDE*/set f(
+ /*error:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE,error:INVALID_OVERRIDE*/set f(
B b) => null;
}
class T3 extends Base {
- /*error:INVALID_METHOD_OVERRIDE*/final B
+ /*error:INVALID_OVERRIDE*/final B
/*error:FINAL_NOT_INITIALIZED*/f;
}
class T4 extends Base {
// two: one for the getter one for the setter.
- /*error:INVALID_METHOD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B f;
+ /*error:INVALID_OVERRIDE, error:INVALID_OVERRIDE*/B f;
}
class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T5 implements Base {
- /*error:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_METHOD_OVERRIDE*/B get f => null;
+ /*error:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_OVERRIDE*/B get f => null;
}
class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T6 implements Base {
- /*error:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_METHOD_OVERRIDE*/set f(B b) => null;
+ /*error:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_OVERRIDE*/set f(B b) => null;
}
class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T7 implements Base {
- /*error:INVALID_METHOD_OVERRIDE*/final B f = null;
+ /*error:INVALID_OVERRIDE*/final B f = null;
}
class T8 implements Base {
// two: one for the getter one for the setter.
- /*error:INVALID_METHOD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B f;
+ /*error:INVALID_OVERRIDE, error:INVALID_OVERRIDE*/B f;
}
''');
}
@@ -2691,7 +2689,7 @@
}
class Test extends Base {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
@@ -2706,11 +2704,12 @@
}
class T1 implements I {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
+ @failingTest
test_invalidOverrides_doubleOverride() async {
await checkFile('''
class A {}
@@ -2725,11 +2724,12 @@
class Test extends Parent {
// Reported only once
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
+ @failingTest
test_invalidOverrides_doubleOverride2() async {
await checkFile('''
class A {}
@@ -2739,7 +2739,7 @@
m(A a) {}
}
class Parent extends Grandparent {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
class Test extends Parent {
@@ -2761,7 +2761,7 @@
}
class Test extends Parent {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
int x;
}
''');
@@ -2780,12 +2780,12 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
- extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+class /*error:INCONSISTENT_INHERITANCE*/T1
+ extends Object with M
implements I {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Object
- with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M implements I;
+class /*error:INCONSISTENT_INHERITANCE*/U1 = Object
+ with M implements I;
''');
}
@@ -2807,20 +2807,20 @@
int x;
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
- with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2 extends Base
- with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1, M2 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T3 extends Base
- with M2, /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1 {}
+class /*error:INCONSISTENT_INHERITANCE*/T1 extends Base
+ with /*error:INVALID_OVERRIDE*/M1 {}
+class /*error:INCONSISTENT_INHERITANCE*/T2 extends Base
+ with /*error:INVALID_OVERRIDE*/M1, M2 {}
+class /*error:INCONSISTENT_INHERITANCE*/T3 extends Base
+ with M2, /*error:INVALID_OVERRIDE*/M1 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Base
- with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1;
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U2 = Base
- with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1, M2;
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U3 = Base
- with M2, /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M1;
+class /*error:INCONSISTENT_INHERITANCE*/U1 = Base
+ with /*error:INVALID_OVERRIDE*/M1;
+class /*error:INCONSISTENT_INHERITANCE*/U2 = Base
+ with /*error:INVALID_OVERRIDE*/M1, M2;
+class /*error:INCONSISTENT_INHERITANCE*/U3 = Base
+ with M2, /*error:INVALID_OVERRIDE*/M1;
''');
}
@@ -2842,16 +2842,17 @@
int x;
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
+class /*error:INCONSISTENT_INHERITANCE*/T1 extends Base
with M1,
- /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2 {}
+ /*error:INVALID_OVERRIDE*/M2 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Base
+class /*error:INCONSISTENT_INHERITANCE*/U1 = Base
with M1,
- /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2;
+ /*error:INVALID_OVERRIDE*/M2;
''');
}
+ @failingTest
test_invalidOverrides_noDuplicateMixinOverride() async {
// This is a regression test for a bug in an earlier implementation were
// names were hiding errors if the first mixin override looked correct,
@@ -2876,11 +2877,11 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
- with M1, /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2, M3 {}
+class /*error:INCONSISTENT_INHERITANCE*/T1 extends Base
+ with M1, /*error:INVALID_OVERRIDE_FROM_MIXIN*/M2, M3 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Base
- with M1, /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2, M3;
+class /*error:INCONSISTENT_INHERITANCE*/U1 = Base
+ with M1, /*error:INVALID_OVERRIDE_FROM_MIXIN*/M2, M3;
''');
}
@@ -2899,20 +2900,20 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
- /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
+class /*error:INCONSISTENT_INHERITANCE*/T1
+ extends Base
implements I1 {}
class T2 extends Base implements I1 {
m(a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T3
- extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/Base
+class /*error:INCONSISTENT_INHERITANCE*/T3
+ extends Object with Base
implements I1 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U3
- = Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/Base
+class /*error:INCONSISTENT_INHERITANCE*/U3
+ = Object with Base
implements I1;
class T4 extends Object with Base implements I1 {
@@ -3050,12 +3051,12 @@
}
class Child extends Base {
- /*error:INVALID_METHOD_OVERRIDE*/A m1(A value) => null;
- /*error:INVALID_METHOD_OVERRIDE*/C m2(C value) => null;
- /*error:INVALID_METHOD_OVERRIDE*/A m3(C value) => null;
+ /*error:INVALID_OVERRIDE*/A m1(A value) => null;
+ /*error:INVALID_OVERRIDE*/C m2(C value) => null;
+ /*error:INVALID_OVERRIDE*/A m3(C value) => null;
C m4(A value) => null;
m5(value) => null;
- /*error:INVALID_METHOD_OVERRIDE*/dynamic m6(dynamic value) => null;
+ /*error:INVALID_OVERRIDE*/dynamic m6(dynamic value) => null;
}
''');
}
@@ -3074,12 +3075,12 @@
}
class G extends F {
- /*error:INVALID_METHOD_OVERRIDE*/void f(int x) {}
+ /*error:INVALID_OVERRIDE*/void f(int x) {}
void g(dynamic x) {}
}
class H implements F {
- /*error:INVALID_METHOD_OVERRIDE*/void f(int x) {}
+ /*error:INVALID_OVERRIDE*/void f(int x) {}
void g(dynamic x) {}
}
''');
@@ -3109,7 +3110,7 @@
class C = Object with B;
-class D extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/C implements A {}
+class /*error:INVALID_OVERRIDE*/D extends Object with C implements A {}
''');
}
@@ -3127,11 +3128,11 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base
- with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M {}
+class /*error:INCONSISTENT_INHERITANCE*/T1 extends Base
+ with /*error:INVALID_OVERRIDE*/M {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Base
- with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M;
+class /*error:INCONSISTENT_INHERITANCE*/U1 = Base
+ with /*error:INVALID_OVERRIDE*/M;
''');
}
@@ -3151,9 +3152,11 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Base with M {}
+class /*error:INCONSISTENT_INHERITANCE*/T1 extends Base
+ with /*error:INVALID_OVERRIDE*/M {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 = Base with M;
+class /*error:INCONSISTENT_INHERITANCE*/U1 = Base
+ with /*error:INVALID_OVERRIDE*/M;
''');
}
@@ -3171,12 +3174,12 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
- extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+class /*error:INCONSISTENT_INHERITANCE*/T1
+ extends Object with M
implements I2 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1
- = Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+class /*error:INCONSISTENT_INHERITANCE*/U1
+ = Object with M
implements I2;
''');
}
@@ -3195,12 +3198,12 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
- extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+class /*error:INCONSISTENT_INHERITANCE*/T1
+ extends Object with M
implements I2 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1
- = Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+class /*error:INCONSISTENT_INHERITANCE*/U1
+ = Object with M
implements I2;
''');
}
@@ -3219,12 +3222,12 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
- extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+class /*error:INCONSISTENT_INHERITANCE*/T1
+ extends Object with M
implements I2 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1
- = Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+class /*error:INCONSISTENT_INHERITANCE*/U1
+ = Object with M
implements I2;
''');
}
@@ -3249,14 +3252,14 @@
// TODO(jmesserly): the `INCONSISTENT_METHOD_INHERITANCE` message is from the
// Dart 1 checking logic (using strong mode type system), it is not produced
// by the strong mode OverrideChecker.
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
+class /*error:INCONSISTENT_INHERITANCE*/T1
extends Base
- with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+ with M
implements I1 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U1 =
+class /*error:INCONSISTENT_INHERITANCE*/U1 =
Base
- with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+ with M
implements I1;
''');
}
@@ -3280,11 +3283,11 @@
class Parent2 extends Grandparent {}
// Note: otherwise both errors would be reported on this line
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
- /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Parent1
+class /*error:INCONSISTENT_INHERITANCE*/T1
+ extends Parent1
implements I1 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2
- /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Parent2
+class /*error:INCONSISTENT_INHERITANCE*/T2
+ extends Parent2
implements I1 {}
''');
}
@@ -3306,9 +3309,8 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1 extends Object
- with M1,
- /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M2
+class /*error:INCONSISTENT_INHERITANCE*/T1 extends Object
+ with M1, M2
implements I1 {}
''');
}
@@ -3326,16 +3328,12 @@
m(B a) {}
}
-// Note: no error reported in `extends Base` to avoid duplicating
-// the error in T1.
class T1 extends Base implements I1 {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
-// If there is no error in the class, we do report the error at
-// the base class:
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2
- /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
+class /*error:INCONSISTENT_INHERITANCE*/T2
+ extends Base
implements I1 {}
''');
}
@@ -3354,19 +3352,20 @@
}
class T1 extends Object with M implements I1 {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2
- extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+class /*error:INCONSISTENT_INHERITANCE*/T2
+ extends Object with M
implements I1 {}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/U2
- = Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
+class /*error:INCONSISTENT_INHERITANCE*/U2
+ = Object with M
implements I1;
''');
}
+ @failingTest
test_noDuplicateReports_typeOverridesSomeMethodInMultipleInterfaces() async {
await checkFile('''
class A {}
@@ -3382,7 +3381,7 @@
class Base {}
class T1 implements I2 {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
@@ -3439,7 +3438,7 @@
n(B b);
}
abstract class D extends C {
- /*error:INVALID_METHOD_OVERRIDE*/m(B b);
+ /*error:INVALID_OVERRIDE*/m(B b);
n(A a);
}
''');
@@ -3464,19 +3463,15 @@
return checkFile(r'''
abstract class A { void test(A arg) { } }
abstract class B extends A {
- /*error:INVALID_METHOD_OVERRIDE*/void test(B arg) { }
+ /*error:INVALID_OVERRIDE*/void test(B arg) { }
}
abstract class X implements A { }
class C extends B {}
-// We treat "with X" as asking for another check.
-// This feels inconsistent.
-class D /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends B with X { }
+class /*error:INVALID_OVERRIDE*/D extends B with X { }
-// We treat "implements A" as asking for another check.
-// This feels inconsistent.
-class E /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends B implements A { }
+class /*error:INVALID_OVERRIDE*/E extends B implements A { }
''');
}
@@ -3498,7 +3493,7 @@
var _f3;
var _f4;
- /*error:INVALID_METHOD_OVERRIDE*/String _m1() => null;
+ /*error:INVALID_OVERRIDE*/String _m1() => null;
}
''', name: '/helper.dart');
await checkFile('''
@@ -3654,15 +3649,15 @@
class G extends F {
void set f(ToVoid<int> x) {}
- /*error:INVALID_METHOD_OVERRIDE*/void set g(ToVoid<dynamic> x) {}
- /*error:INVALID_METHOD_OVERRIDE*/void set h(int x) {}
+ /*error:INVALID_OVERRIDE*/void set g(ToVoid<dynamic> x) {}
+ /*error:INVALID_OVERRIDE*/void set h(int x) {}
void set i(dynamic x) {}
}
class H implements F {
void set f(ToVoid<int> x) {}
- /*error:INVALID_METHOD_OVERRIDE*/void set g(ToVoid<dynamic> x) {}
- /*error:INVALID_METHOD_OVERRIDE*/void set h(int x) {}
+ /*error:INVALID_OVERRIDE*/void set g(ToVoid<dynamic> x) {}
+ /*error:INVALID_OVERRIDE*/void set h(int x) {}
void set i(dynamic x) {}
}
''');
@@ -3702,7 +3697,7 @@
class Child extends Base {
void set f1(A value) {}
- /*error:INVALID_METHOD_OVERRIDE*/void set f2(C value) {}
+ /*error:INVALID_OVERRIDE*/void set f2(C value) {}
void set f3(value) {}
void set f4(dynamic value) {}
set f5(B value) {}
@@ -3755,7 +3750,7 @@
}
abstract class Base implements I1 {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
class T1 extends Base {
@@ -3764,7 +3759,7 @@
// TODO(sigmund): consider tracking overrides in a fine-grain
// manner, then this and the double-overrides would not be
// reported.
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
@@ -3779,11 +3774,11 @@
}
class Base implements I1 {
- /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
class T1 extends Base {
- m(B a) {}
+ /*error:INVALID_OVERRIDE*/m(B a) {}
}
''');
}
@@ -3802,8 +3797,8 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
- /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base implements I2 {}
+class /*error:INCONSISTENT_INHERITANCE*/T1
+ extends Base implements I2 {}
''');
}
@@ -3821,8 +3816,8 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
- /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
+class /*error:INCONSISTENT_INHERITANCE*/T1
+ extends Base
implements I2 {}
''');
}
@@ -3841,8 +3836,8 @@
m(B a) {}
}
-class /*error:INCONSISTENT_METHOD_INHERITANCE*/T1
- /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
+class /*error:INCONSISTENT_INHERITANCE*/T1
+ extends Base
implements I2 {}
''');
}
@@ -3872,7 +3867,7 @@
}
// This mixin application doesn't provide a valid superclass for B
-class D extends C with /*error:INCONSISTENT_METHOD_INHERITANCE*/B {}
+class D extends C with /*error:INCONSISTENT_INHERITANCE*/B {}
}
''', superMixins: true);
}
@@ -4352,7 +4347,7 @@
}
class B extends A {
- /*error:INVALID_METHOD_OVERRIDE*/T method<T>(T x) => x;
+ /*error:INVALID_OVERRIDE*/T method<T>(T x) => x;
}
''');
}
@@ -4385,12 +4380,6 @@
@override
bool get enableNewAnalysisDriver => true;
- @failingTest
- @override
- test_covariantOverride_fields() async {
- await super.test_covariantOverride_fields();
- }
-
@override // Passes with driver
test_interfacesFromMixinsUsedTwiceAreChecked() =>
super.test_interfacesFromMixinsUsedTwiceAreChecked();
diff --git a/pkg/analyzer/test/src/task/strong/inferred_type_test.dart b/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
index b2e2a7a..d1137b6 100644
--- a/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
+++ b/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
@@ -431,12 +431,12 @@
}
class C1 implements A, B {
- /*error:INVALID_METHOD_OVERRIDE*/get a => null;
+ /*error:INVALID_OVERRIDE,error:INVALID_OVERRIDE*/get a => null;
}
// Still ambiguous
class C2 implements B, A {
- /*error:INVALID_METHOD_OVERRIDE*/get a => null;
+ /*error:INVALID_OVERRIDE,error:INVALID_OVERRIDE*/get a => null;
}
''');
}
@@ -468,7 +468,7 @@
}
class C2 implements A, B {
- /*error:INVALID_METHOD_OVERRIDE*/get a => null;
+ /*error:INVALID_OVERRIDE,error:INVALID_OVERRIDE*/get a => null;
}
''');
}
@@ -751,7 +751,7 @@
}
class B implements A {
- /*error:INVALID_METHOD_OVERRIDE*/dynamic get x => 3;
+ /*error:INVALID_OVERRIDE*/dynamic get x => 3;
}
foo() {
@@ -1908,7 +1908,7 @@
T m<T>(T x) => x;
}
class D extends C {
-/*error:INVALID_METHOD_OVERRIDE*/m(x) => x;
+/*error:INVALID_OVERRIDE*/m(x) => x;
}
main() {
int y = /*info:DYNAMIC_CAST*/new D()./*error:WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD*/m<int>(42);
@@ -1955,8 +1955,8 @@
dynamic g(int x) => x;
}
class D extends C {
- /*error:INVALID_METHOD_OVERRIDE*/T m<T>(T x) => x;
- /*error:INVALID_METHOD_OVERRIDE*/T g<T>(T x) => x;
+ /*error:INVALID_OVERRIDE*/T m<T>(T x) => x;
+ /*error:INVALID_OVERRIDE*/T g<T>(T x) => x;
}
main() {
int y = /*info:DYNAMIC_CAST*/(/*info:UNNECESSARY_CAST*/new D() as C).m(42);
@@ -3383,7 +3383,7 @@
}
class B implements A<int> {
- /*error:INVALID_METHOD_OVERRIDE*/dynamic get x => 3;
+ /*error:INVALID_OVERRIDE*/dynamic get x => 3;
}
foo() {
diff --git a/pkg/analyzer_cli/test/strong_mode_test.dart b/pkg/analyzer_cli/test/strong_mode_test.dart
index 30f7815..85a4928 100644
--- a/pkg/analyzer_cli/test/strong_mode_test.dart
+++ b/pkg/analyzer_cli/test/strong_mode_test.dart
@@ -30,7 +30,7 @@
expect(exitCode, 3);
var stdout = bulletToDash(outSink);
- expect(stdout, contains('error - Invalid override'));
+ expect(stdout, contains("isn't a valid override of"));
expect(stdout, contains('error - The list literal type'));
expect(stdout, contains('2 errors found'));
}
diff --git a/tests/language_2/language_2_analyzer.status b/tests/language_2/language_2_analyzer.status
index 0389ef8..15e3401 100644
--- a/tests/language_2/language_2_analyzer.status
+++ b/tests/language_2/language_2_analyzer.status
@@ -5,8 +5,6 @@
# Sections in this file should contain "$compiler == dart2analyzer".
[ $compiler == dart2analyzer ]
-abstract_override_adds_optional_args_concrete_subclass_test: MissingCompileTimeError # Issue #30568
-abstract_override_adds_optional_args_concrete_test: MissingCompileTimeError # Issue #30568
accessor_conflict_export2_test: CompileTimeError # Issue 25626
accessor_conflict_export_test: CompileTimeError # Issue 25626
accessor_conflict_import2_test: CompileTimeError # Issue 25626
@@ -14,6 +12,7 @@
accessor_conflict_import_prefixed_test: CompileTimeError # Issue 25626
accessor_conflict_import_test: CompileTimeError # Issue 25626
additional_interface_adds_optional_args_test: CompileTimeError # Issue #30568
+bug34235_test/01: Pass
cascaded_forwarding_stubs_test: CompileTimeError # Issue 34329
config_import_corelib_test: CompileTimeError, StaticWarning, OK # failing-by-design: Will never pass, see Issue #34332
conflicting_generic_interfaces_hierarchy_loop_infinite_test: Skip # Issue #34333 (loops forever)
@@ -109,7 +108,6 @@
regress_30121_test: CompileTimeError # Issue 31087
regress_30339_test: CompileTimeError
regress_32660_test/01: MissingCompileTimeError # Issue #32660.
-regress_32660_test/04: CompileTimeError
regress_33479_test/01: Crash # Issue #33479
setter3_test/01: CompileTimeError # Invalid test, see https://github.com/dart-lang/sdk/issues/33837
setter3_test/02: CompileTimeError # Invalid test, see https://github.com/dart-lang/sdk/issues/33837
diff --git a/tests/language_2/language_2_dartdevc.status b/tests/language_2/language_2_dartdevc.status
index ae94dee..4a7d144 100644
--- a/tests/language_2/language_2_dartdevc.status
+++ b/tests/language_2/language_2_dartdevc.status
@@ -4,8 +4,6 @@
# Sections in this file should contain "$compiler == dartdevc" or dartdevk.
[ $compiler == dartdevc ]
-abstract_override_adds_optional_args_concrete_subclass_test: MissingCompileTimeError # Issue #30568
-abstract_override_adds_optional_args_concrete_test: MissingCompileTimeError # Issue #30568
accessor_conflict_export2_test: CompileTimeError # Issue 25626
accessor_conflict_export_test: CompileTimeError # Issue 25626
accessor_conflict_import2_test: CompileTimeError # Issue 25626
@@ -22,6 +20,7 @@
await_future_test: Pass, Timeout # Issue 29920
bit_operations_test: RuntimeError # No bigints on web.
bug32372_test: RuntimeError
+bug34235_test/01: Pass
built_in_identifier_prefix_test: CompileTimeError
built_in_identifier_type_annotation_test/dynamic-funarg: RuntimeError # Issue 28816
built_in_identifier_type_annotation_test/dynamic-funret: RuntimeError # Issue 28816
@@ -106,15 +105,15 @@
issue34498_test: MissingCompileTimeError # Issue 34500
label_test: RuntimeError
left_shift_test: RuntimeError # Ints and doubles are unified.
-mixin_declaration/mixin_declaration_inference_invalid_03_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
-mixin_declaration/mixin_declaration_inference_invalid_04_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
-mixin_declaration/mixin_declaration_inference_invalid_05_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
-mixin_declaration/mixin_declaration_inference_invalid_06_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
-mixin_declaration/mixin_declaration_inference_invalid_07_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
-mixin_declaration/mixin_declaration_inference_invalid_08_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
-mixin_declaration/mixin_declaration_inference_invalid_09_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
-mixin_declaration/mixin_declaration_inference_invalid_10_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
-mixin_declaration/mixin_declaration_inference_invalid_11_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
+mixin_declaration/mixin_declaration_inference_invalid_03_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
+mixin_declaration/mixin_declaration_inference_invalid_04_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
+mixin_declaration/mixin_declaration_inference_invalid_05_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
+mixin_declaration/mixin_declaration_inference_invalid_06_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
+mixin_declaration/mixin_declaration_inference_invalid_07_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
+mixin_declaration/mixin_declaration_inference_invalid_08_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
+mixin_declaration/mixin_declaration_inference_invalid_09_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
+mixin_declaration/mixin_declaration_inference_invalid_10_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
+mixin_declaration/mixin_declaration_inference_invalid_11_test: MissingCompileTimeError # https://github.com/dart-lang/sdk/issues/34167
mixin_declaration/mixin_declaration_inference_valid_A00_test: CompileTimeError # Issue #34164
mixin_declaration/mixin_declaration_inference_valid_A01_test: CompileTimeError # Issue #34164
mixin_declaration/mixin_declaration_inference_valid_A02_test: CompileTimeError # Issue #34164
@@ -144,8 +143,8 @@
mixin_declaration/mixin_declaration_inference_valid_C11_test: CompileTimeError # Issue #34164
mixin_declaration/mixin_declaration_inference_valid_C12_test: CompileTimeError # Issue #34164
mixin_declaration/mixin_declaration_inference_valid_C13_test: CompileTimeError # Issue #34164
-mixin_declaration/mixin_declaration_inference_valid_mixin_applications_test: CompileTimeError # https://github.com/dart-lang/sdk/issues/34164
-mixin_declaration/mixin_declaration_invalid_superinvocation_test/10: CompileTimeError # Analyzer chooses wrong(?) super method.
+mixin_declaration/mixin_declaration_inference_valid_mixin_applications_test: CompileTimeError # https://github.com/dart-lang/sdk/issues/34164
+mixin_declaration/mixin_declaration_invalid_superinvocation_test/10: CompileTimeError # Analyzer chooses wrong(?) super method.
mixin_method_override_test/01: MissingCompileTimeError # Issue 34235
mixin_super_2_test/01: MissingCompileTimeError
mixin_super_2_test/03: MissingCompileTimeError
@@ -182,7 +181,6 @@
regress_30121_test: CompileTimeError # Issue 31087
regress_30339_test: CompileTimeError # As expected. Should we make this a multi test?
regress_32660_test/01: MissingCompileTimeError # Issue #32660.
-regress_32660_test/04: CompileTimeError
regress_33479_test/01: Crash # Issue #33479
setter3_test/01: CompileTimeError # Invalid test, see https://github.com/dart-lang/sdk/issues/33837
setter3_test/02: CompileTimeError # Invalid test, see https://github.com/dart-lang/sdk/issues/33837
