Version 1.23.0-dev.9.1
Cherry-pick f212815ca303b5067d108554045229b2a475ef77 into dev
Cherry-pick 5dfc281f2f34165d3f0c1e96204c530e35dd200a into dev
diff --git a/pkg/analyzer/lib/src/dart/element/member.dart b/pkg/analyzer/lib/src/dart/element/member.dart
index 95aafe1..bb96168 100644
--- a/pkg/analyzer/lib/src/dart/element/member.dart
+++ b/pkg/analyzer/lib/src/dart/element/member.dart
@@ -10,8 +10,7 @@
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/type.dart';
-import 'package:analyzer/src/generated/engine.dart'
- show AnalysisContext, AnalysisEngine;
+import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
import 'package:analyzer/src/generated/java_engine.dart';
import 'package:analyzer/src/generated/source.dart';
import 'package:analyzer/src/generated/utilities_dart.dart';
@@ -301,7 +300,7 @@
* was created.
*/
static FieldElement from(FieldElement field, ParameterizedType definingType) {
- if (!_isChangedByTypeSubstitution(field, definingType)) {
+ if (field == null || definingType.typeArguments.isEmpty) {
return field;
}
// TODO(brianwilkerson) Consider caching the substituted type in the
@@ -309,39 +308,6 @@
// We need to see how often the type is being re-computed.
return new FieldMember(field, definingType);
}
-
- /**
- * Determine whether the given [field]'s type is changed when type parameters
- * from the [definingType]'s declaration are replaced with the actual type
- * arguments from the defining type.
- */
- static bool _isChangedByTypeSubstitution(
- FieldElement field, ParameterizedType definingType) {
- List<DartType> argumentTypes = definingType.typeArguments;
- if (field != null && argumentTypes.length != 0) {
- DartType baseType = field.type;
- List<DartType> parameterTypes =
- TypeParameterTypeImpl.getTypes(definingType.typeParameters);
- if (baseType != null) {
- DartType substitutedType =
- baseType.substitute2(argumentTypes, parameterTypes);
- if (baseType != substitutedType) {
- return true;
- }
- }
- // If the field has a propagated type, then we need to check whether the
- // propagated type needs substitution.
- DartType basePropagatedType = field.propagatedType;
- if (basePropagatedType != null) {
- DartType substitutedPropagatedType =
- basePropagatedType.substitute2(argumentTypes, parameterTypes);
- if (basePropagatedType != substitutedPropagatedType) {
- return true;
- }
- }
- }
- return false;
- }
}
/**
@@ -843,7 +809,7 @@
*/
static PropertyAccessorElement from(
PropertyAccessorElement accessor, InterfaceType definingType) {
- if (!_isChangedByTypeSubstitution(accessor, definingType)) {
+ if (accessor == null || definingType.typeArguments.isEmpty) {
return accessor;
}
// TODO(brianwilkerson) Consider caching the substituted type in the
@@ -851,45 +817,6 @@
// We need to see how often the type is being re-computed.
return new PropertyAccessorMember(accessor, definingType);
}
-
- /**
- * Determine whether the given property [accessor]'s type is changed when type
- * parameters from the defining type's declaration are replaced with the
- * actual type arguments from the [definingType].
- */
- static bool _isChangedByTypeSubstitution(
- PropertyAccessorElement accessor, InterfaceType definingType) {
- List<DartType> argumentTypes = definingType.typeArguments;
- if (accessor != null && argumentTypes.length != 0) {
- FunctionType baseType = accessor.type;
- if (baseType == null) {
- AnalysisEngine.instance.logger.logInformation(
- 'Type of $accessor is null in PropertyAccessorMember._isChangedByTypeSubstitution');
- return false;
- }
- List<DartType> parameterTypes = definingType.element.type.typeArguments;
- FunctionType substitutedType =
- baseType.substitute2(argumentTypes, parameterTypes);
- if (baseType != substitutedType) {
- return true;
- }
- // If this property accessor is based on a field, that field might have a
- // propagated type. In which case we need to check whether the propagated
- // type of the field needs substitution.
- PropertyInducingElement field = accessor.variable;
- if (!field.isSynthetic) {
- DartType baseFieldType = field.propagatedType;
- if (baseFieldType != null) {
- DartType substitutedFieldType =
- baseFieldType.substitute2(argumentTypes, parameterTypes);
- if (baseFieldType != substitutedFieldType) {
- return true;
- }
- }
- }
- }
- return false;
- }
}
/**
diff --git a/pkg/analyzer/lib/src/summary/link.dart b/pkg/analyzer/lib/src/summary/link.dart
index 0945db2..9aed72a 100644
--- a/pkg/analyzer/lib/src/summary/link.dart
+++ b/pkg/analyzer/lib/src/summary/link.dart
@@ -2583,8 +2583,8 @@
FunctionType _inferExecutableType(
FunctionType rawMethodType,
- int numNamed,
- int numPositional,
+ int numNamedArguments,
+ int numPositionalArguments,
List<String> namedArgNames,
List<DartType> namedArgTypeList,
List<DartType> positionalArgTypes,
@@ -2599,36 +2599,46 @@
}
} else if (rawMethodType.typeFormals.isNotEmpty &&
ts is StrongTypeSystemImpl) {
- List<DartType> paramTypes = <DartType>[];
- List<DartType> argTypes = <DartType>[];
- // Add positional parameter and argument types.
- for (int i = 0; i < numPositional; i++) {
- ParameterElement parameter = rawMethodType.parameters[i];
- if (parameter != null) {
- paramTypes.add(parameter.type);
- argTypes.add(positionalArgTypes[i]);
- }
- }
- // Prepare named argument types map.
+ // Prepare the named argument types map.
Map<String, DartType> namedArgTypes = <String, DartType>{};
- for (int i = 0; i < numNamed; i++) {
+ for (int i = 0; i < numNamedArguments; i++) {
String name = namedArgNames[i];
DartType type = namedArgTypeList[i];
namedArgTypes[name] = type;
}
- // Add named parameter and argument types.
- Map<String, DartType> namedParameterTypes =
- rawMethodType.namedParameterTypes;
- namedArgTypes.forEach((String name, DartType argType) {
- DartType parameterType = namedParameterTypes[name];
- if (parameterType != null) {
- paramTypes.add(parameterType);
- argTypes.add(argType);
+
+ // Fill parameters and the corresponding arguments.
+ List<DartType> parameterTypes = <DartType>[];
+ List<DartType> argumentTypes = <DartType>[];
+ int positionalIndex = 0;
+ int numRequiredParameters = 0;
+ for (ParameterElement parameter in rawMethodType.parameters) {
+ if (parameter.parameterKind == ParameterKind.REQUIRED) {
+ numRequiredParameters++;
+ if (numRequiredParameters > numPositionalArguments) {
+ return null;
+ }
+ parameterTypes.add(parameter.type);
+ argumentTypes.add(positionalArgTypes[positionalIndex]);
+ positionalIndex++;
+ } else if (parameter.parameterKind == ParameterKind.POSITIONAL) {
+ if (positionalIndex < numPositionalArguments) {
+ parameterTypes.add(parameter.type);
+ argumentTypes.add(positionalArgTypes[positionalIndex]);
+ positionalIndex++;
+ }
+ } else if (parameter.parameterKind == ParameterKind.NAMED) {
+ DartType namedArgumentType = namedArgTypes[parameter.name];
+ if (namedArgumentType != null) {
+ parameterTypes.add(parameter.type);
+ argumentTypes.add(namedArgumentType);
+ }
}
- });
+ }
+
// Perform inference.
FunctionType inferred = ts.inferGenericFunctionCall(rawMethodType,
- paramTypes, argTypes, rawMethodType.returnType, null);
+ parameterTypes, argumentTypes, rawMethodType.returnType, null);
return inferred;
}
}
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 58b26a0..6be721b 100644
--- a/pkg/analyzer/test/src/summary/top_level_inference_test.dart
+++ b/pkg/analyzer/test/src/summary/top_level_inference_test.dart
@@ -432,7 +432,7 @@
test_initializer_methodInvocation_hasTypeParameters() async {
var library = await _encodeDecodeLibrary(r'''
class A {
- List<T> m<T>(int p) => null;
+ List<T> m<T>() => null;
}
var vWithTypeArgument = new A().m<int>();
var vWithoutTypeArgument = new A().m();
@@ -631,6 +631,31 @@
''');
}
+ test_instanceField_functionTypeAlias_doesNotUseItsTypeParameter() async {
+ var library = await _encodeDecodeLibrary(r'''
+typedef F<T>();
+
+class A<T> {
+ F<T> get x => null;
+}
+
+class B extends A<int> {
+ get x => null;
+}
+''');
+ checkElementText(
+ library,
+ r'''
+typedef dynamic F<T>();
+class A<T> {
+ F get x {}
+}
+class B extends A<int> {
+ F get x {}
+}
+''');
+ }
+
test_method_error_conflict_parameterType_generic() async {
var library = await _encodeDecodeLibrary(r'''
class A<T> {
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 de02780..3e97028 100644
--- a/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
+++ b/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
@@ -869,6 +869,15 @@
''');
}
+ test_constructors_tooManyPositionalArguments() async {
+ var unit = await checkFileElement(r'''
+class A<T> {}
+var a = new A/*error:EXTRA_POSITIONAL_ARGUMENTS*/(42);
+''');
+ var vars = unit.topLevelVariables;
+ expect(vars[0].type.toString(), 'A<dynamic>');
+ }
+
test_doNotInferOverriddenFieldsThatExplicitlySayDynamic_infer() async {
await checkFileElement('''
class A {
diff --git a/tools/VERSION b/tools/VERSION
index 6605793..9aa7e6f6 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -28,4 +28,4 @@
MINOR 23
PATCH 0
PRERELEASE 9
-PRERELEASE_PATCH 0
+PRERELEASE_PATCH 1
