Version 2.10.0-49.0.dev
Merge commit '1c69c696508fd4822d778582b7ae32c9d2932b5a' into 'dev'
diff --git a/pkg/analyzer/lib/src/dart/resolver/variable_declaration_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/variable_declaration_resolver.dart
new file mode 100644
index 0000000..ce9ed26
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/resolver/variable_declaration_resolver.dart
@@ -0,0 +1,96 @@
+// Copyright (c) 2020, 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/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/constant/utilities.dart';
+import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/type_demotion.dart';
+import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/resolver.dart';
+import 'package:meta/meta.dart';
+
+/// Helper for resolving [VariableDeclaration]s.
+class VariableDeclarationResolver {
+ final ResolverVisitor _resolver;
+ final FlowAnalysisHelper _flowAnalysis;
+ final bool _strictInference;
+
+ VariableDeclarationResolver({
+ @required ResolverVisitor resolver,
+ @required FlowAnalysisHelper flowAnalysis,
+ @required bool strictInference,
+ }) : _resolver = resolver,
+ _flowAnalysis = flowAnalysis,
+ _strictInference = strictInference;
+
+ void resolve(VariableDeclarationImpl node) {
+ var parent = node.parent as VariableDeclarationList;
+
+ var initializer = node.initializer;
+
+ if (initializer == null) {
+ if (_strictInference && parent.type == null) {
+ _resolver.errorReporter.reportErrorForNode(
+ HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE,
+ node,
+ [node.name.name],
+ );
+ }
+ return;
+ }
+
+ var element = node.declaredElement;
+ var isTopLevel =
+ element is FieldElement || element is TopLevelVariableElement;
+
+ InferenceContext.setTypeFromNode(initializer, node);
+ if (isTopLevel) {
+ _flowAnalysis?.topLevelDeclaration_enter(node, null, null);
+ }
+
+ initializer.accept(_resolver);
+ initializer = node.initializer;
+
+ if (parent.type == null) {
+ _setInferredType(element, initializer.staticType);
+ }
+
+ if (element.initializer != null) {
+ var initializerFunction = element.initializer as FunctionElementImpl;
+ initializerFunction.returnType = initializer.staticType;
+ }
+
+ if (isTopLevel) {
+ _flowAnalysis?.topLevelDeclaration_exit();
+ }
+
+ // Note: in addition to cloning the initializers for const variables, we
+ // have to clone the initializers for non-static final fields (because if
+ // they occur in a class with a const constructor, they will be needed to
+ // evaluate the const constructor).
+ if (element is ConstVariableElement) {
+ (element as ConstVariableElement).constantInitializer =
+ ConstantAstCloner().cloneNode(initializer);
+ }
+ }
+
+ void _setInferredType(VariableElement element, DartType initializerType) {
+ if (element is LocalVariableElementImpl) {
+ if (initializerType.isDartCoreNull) {
+ initializerType = DynamicTypeImpl.instance;
+ }
+
+ var inferredType = demoteType(
+ _resolver.definingLibrary,
+ initializerType,
+ );
+ element.type = inferredType;
+ }
+ }
+}
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 5966e9e..32fd184 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -38,6 +38,7 @@
import 'package:analyzer/src/dart/resolver/scope.dart';
import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
import 'package:analyzer/src/dart/resolver/typed_literal_resolver.dart';
+import 'package:analyzer/src/dart/resolver/variable_declaration_resolver.dart';
import 'package:analyzer/src/dart/resolver/yield_statement_resolver.dart';
import 'package:analyzer/src/error/bool_expression_verifier.dart';
import 'package:analyzer/src/error/codes.dart';
@@ -45,6 +46,7 @@
import 'package:analyzer/src/error/nullable_dereference_verifier.dart';
import 'package:analyzer/src/generated/constant.dart';
import 'package:analyzer/src/generated/element_resolver.dart';
+import 'package:analyzer/src/generated/engine.dart';
import 'package:analyzer/src/generated/migratable_ast_info_provider.dart';
import 'package:analyzer/src/generated/migration.dart';
import 'package:analyzer/src/generated/source.dart';
@@ -171,6 +173,7 @@
ForResolver _forResolver;
PostfixExpressionResolver _postfixExpressionResolver;
PrefixExpressionResolver _prefixExpressionResolver;
+ VariableDeclarationResolver _variableDeclarationResolver;
YieldStatementResolver _yieldStatementResolver;
NullSafetyDeadCodeVerifier nullSafetyDeadCodeVerifier;
@@ -290,6 +293,10 @@
super(definingLibrary, source, typeProvider, errorListener,
nameScope: nameScope) {
_promoteManager = TypePromotionManager(typeSystem);
+
+ var analysisOptions =
+ definingLibrary.context.analysisOptions as AnalysisOptionsImpl;
+
nullableDereferenceVerifier = NullableDereferenceVerifier(
typeSystem: typeSystem,
errorReporter: errorReporter,
@@ -341,6 +348,11 @@
resolver: this,
flowAnalysis: _flowAnalysis,
);
+ _variableDeclarationResolver = VariableDeclarationResolver(
+ resolver: this,
+ flowAnalysis: _flowAnalysis,
+ strictInference: analysisOptions.strictInference,
+ );
_yieldStatementResolver = YieldStatementResolver(
resolver: this,
);
@@ -1720,29 +1732,10 @@
@override
void visitVariableDeclaration(VariableDeclaration node) {
- var grandParent = node.parent.parent;
- bool isTopLevel = grandParent is FieldDeclaration ||
- grandParent is TopLevelVariableDeclaration;
- InferenceContext.setTypeFromNode(node.initializer, node);
- if (isTopLevel) {
- _flowAnalysis?.topLevelDeclaration_enter(node, null, null);
- }
- super.visitVariableDeclaration(node);
- if (isTopLevel) {
- _flowAnalysis?.topLevelDeclaration_exit();
- }
- VariableElement element = node.declaredElement;
- if (element.initializer != null && node.initializer != null) {
- var initializer = element.initializer as FunctionElementImpl;
- initializer.returnType = node.initializer.staticType;
- }
- // Note: in addition to cloning the initializers for const variables, we
- // have to clone the initializers for non-static final fields (because if
- // they occur in a class with a const constructor, they will be needed to
- // evaluate the const constructor).
- if (element is ConstVariableElement) {
- (element as ConstVariableElement).constantInitializer =
- _createCloner().cloneNode(node.initializer);
+ _variableDeclarationResolver.resolve(node);
+
+ if (node.parent.parent is ForParts) {
+ _define(node.declaredElement);
}
}
diff --git a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
index 2ccef51..3f662eb 100644
--- a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
+++ b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
@@ -12,12 +12,10 @@
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/member.dart' show ConstructorMember;
import 'package:analyzer/src/dart/element/type.dart';
-import 'package:analyzer/src/dart/element/type_demotion.dart';
import 'package:analyzer/src/dart/element/type_provider.dart';
import 'package:analyzer/src/dart/element/type_system.dart';
import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
import 'package:analyzer/src/error/codes.dart';
-import 'package:analyzer/src/generated/engine.dart';
import 'package:analyzer/src/generated/migration.dart';
import 'package:analyzer/src/generated/resolver.dart';
import 'package:analyzer/src/generated/variable_type_provider.dart';
@@ -49,9 +47,6 @@
/// The type representing the type 'dynamic'.
DartType _dynamicType;
- /// True if inference failures should be reported, otherwise false.
- bool _strictInference;
-
/// The object providing promoted or declared types of variables.
LocalVariableTypeProvider _localVariableTypeProvider;
@@ -67,9 +62,6 @@
_typeSystem = _resolver.typeSystem;
_dynamicType = _typeProvider.dynamicType;
_localVariableTypeProvider = _resolver.localVariableTypeProvider;
- AnalysisOptionsImpl analysisOptions =
- _resolver.definingLibrary.context.analysisOptions;
- _strictInference = analysisOptions.strictInference;
}
/// Is `true` if the library being analyzed is non-nullable by default.
@@ -583,11 +575,6 @@
recordStaticType(node, _typeProvider.bottomType);
}
- @override
- void visitVariableDeclaration(VariableDeclaration node) {
- _inferLocalVariableType(node, node.initializer);
- }
-
/// Set the static type of [node] to be the least upper bound of the static
/// types of subexpressions [expr1] and [expr2].
void _analyzeLeastUpperBound(
@@ -751,39 +738,6 @@
}
}
- /// Given a local variable declaration and its initializer, attempt to infer
- /// a type for the local variable declaration based on the initializer.
- /// Inference is only done if an explicit type is not present, and if
- /// inferring a type improves the type.
- void _inferLocalVariableType(
- VariableDeclaration node, Expression initializer) {
- AstNode parent = node.parent;
- if (initializer != null) {
- if (parent is VariableDeclarationList && parent.type == null) {
- DartType type = initializer.staticType;
- if (type != null && !type.isDartCoreNull) {
- VariableElement element = node.declaredElement;
- if (element is LocalVariableElementImpl) {
- var initializerType = initializer.staticType;
- var inferredType = demoteType(
- _resolver.definingLibrary,
- initializerType,
- );
- element.type = inferredType;
- }
- }
- }
- } else if (_strictInference) {
- if (parent is VariableDeclarationList && parent.type == null) {
- _resolver.errorReporter.reportErrorForNode(
- HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE,
- node,
- [node.name.name],
- );
- }
- }
- }
-
/// Given a property access [node] with static type [nodeType],
/// and [id] is the property name being accessed, infer a type for the
/// access itself and its constituent components if the access is to one of the
diff --git a/pkg/analyzer/test/src/diagnostics/undefined_identifier_test.dart b/pkg/analyzer/test/src/diagnostics/undefined_identifier_test.dart
index 33b8193..a173cf5 100644
--- a/pkg/analyzer/test/src/diagnostics/undefined_identifier_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/undefined_identifier_test.dart
@@ -57,6 +57,18 @@
]);
}
+ test_forStatement_ForPartsWithDeclarations_initializer() async {
+ await assertErrorsInCode('''
+void f() {
+ for (var x = x;;) {
+ x;
+ }
+}
+''', [
+ error(CompileTimeErrorCode.UNDEFINED_IDENTIFIER, 26, 1),
+ ]);
+ }
+
test_forStatement_inBody() async {
await assertNoErrorsInCode('''
f() {
diff --git a/runtime/lib/mirrors.cc b/runtime/lib/mirrors.cc
index 532f2f6..0bed69c 100644
--- a/runtime/lib/mirrors.cc
+++ b/runtime/lib/mirrors.cc
@@ -64,10 +64,12 @@
args.SetAt(6, argument_names);
const Library& libcore = Library::Handle(Library::CoreLibrary());
- const Class& NoSuchMethodError =
+ const Class& cls =
Class::Handle(libcore.LookupClass(Symbols::NoSuchMethodError()));
- const Function& throwNew = Function::Handle(
- NoSuchMethodError.LookupFunctionAllowPrivate(Symbols::ThrowNew()));
+ const auto& error = cls.EnsureIsFinalized(Thread::Current());
+ ASSERT(error == Error::null());
+ const Function& throwNew =
+ Function::Handle(cls.LookupFunctionAllowPrivate(Symbols::ThrowNew()));
const Object& result =
Object::Handle(DartEntry::InvokeFunction(throwNew, args));
ASSERT(result.IsError());
diff --git a/runtime/vm/code_descriptors_test.cc b/runtime/vm/code_descriptors_test.cc
index 20c0e5e..c5faf2a 100644
--- a/runtime/vm/code_descriptors_test.cc
+++ b/runtime/vm/code_descriptors_test.cc
@@ -71,6 +71,8 @@
// Now compile the two functions 'A.foo' and 'A.moo'
String& function_moo_name = String::Handle(String::New("moo"));
+ const auto& error = cls.EnsureIsFinalized(thread);
+ EXPECT(error == Error::null());
Function& function_moo =
Function::Handle(cls.LookupStaticFunction(function_moo_name));
EXPECT(CompilerTest::TestCompileFunction(function_moo));
diff --git a/runtime/vm/compilation_trace.cc b/runtime/vm/compilation_trace.cc
index 174c252..173652f 100644
--- a/runtime/vm/compilation_trace.cc
+++ b/runtime/vm/compilation_trace.cc
@@ -895,8 +895,10 @@
// ensure no arity mismatch crashes.
target_name_ = call_site_.target_name();
args_desc_ = call_site_.arguments_descriptor();
- target_ = Resolver::ResolveDynamicForReceiverClass(
- cls_, target_name_, ArgumentsDescriptor(args_desc_));
+ if (cls_.EnsureIsFinalized(thread_) == Error::null()) {
+ target_ = Resolver::ResolveDynamicForReceiverClass(
+ cls_, target_name_, ArgumentsDescriptor(args_desc_));
+ }
if (!target_.IsNull()) {
if (num_checked_arguments == 1) {
call_site_.AddReceiverCheck(cids[0], target_, entry_usage);
diff --git a/runtime/vm/compiler/backend/flow_graph.cc b/runtime/vm/compiler/backend/flow_graph.cc
index 5890545..9196b2d 100644
--- a/runtime/vm/compiler/backend/flow_graph.cc
+++ b/runtime/vm/compiler/backend/flow_graph.cc
@@ -538,9 +538,10 @@
if (receiver_maybe_null) {
const Class& null_class =
Class::Handle(zone(), isolate()->object_store()->null_class());
- const Function& target = Function::Handle(
- zone(),
- Resolver::ResolveDynamicAnyArgs(zone(), null_class, method_name));
+ Function& target = Function::Handle(zone());
+ if (null_class.EnsureIsFinalized(thread()) == Error::null()) {
+ target = Resolver::ResolveDynamicAnyArgs(zone(), null_class, method_name);
+ }
if (!target.IsNull()) {
return ToCheck::kCheckCid;
}
diff --git a/runtime/vm/compiler/backend/type_propagator.cc b/runtime/vm/compiler/backend/type_propagator.cc
index 3eddad6..83edc77 100644
--- a/runtime/vm/compiler/backend/type_propagator.cc
+++ b/runtime/vm/compiler/backend/type_propagator.cc
@@ -301,10 +301,14 @@
// Nothing to do if type is already non-nullable.
return;
}
+ Thread* thread = Thread::Current();
const Class& null_class =
- Class::Handle(Isolate::Current()->object_store()->null_class());
- const Function& target = Function::Handle(Resolver::ResolveDynamicAnyArgs(
- Thread::Current()->zone(), null_class, function_name));
+ Class::Handle(thread->isolate()->object_store()->null_class());
+ Function& target = Function::Handle();
+ if (Error::Handle(null_class.EnsureIsFinalized(thread)).IsNull()) {
+ target = Resolver::ResolveDynamicAnyArgs(thread->zone(), null_class,
+ function_name);
+ }
if (target.IsNull()) {
// If the selector is not defined on Null, we can propagate non-nullness.
CompileType* type = TypeOf(receiver);
diff --git a/runtime/vm/compiler/cha_test.cc b/runtime/vm/compiler/cha_test.cc
index 1cd26e9..2e3d38f 100644
--- a/runtime/vm/compiler/cha_test.cc
+++ b/runtime/vm/compiler/cha_test.cc
@@ -38,6 +38,7 @@
const Class& class_a =
Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
EXPECT(!class_a.IsNull());
+ EXPECT(class_a.EnsureIsFinalized(thread) == Error::null());
const Class& class_b =
Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "B"))));
@@ -46,10 +47,12 @@
const Class& class_c =
Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "C"))));
EXPECT(!class_c.IsNull());
+ EXPECT(class_c.EnsureIsFinalized(thread) == Error::null());
const Class& class_d =
Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "D"))));
EXPECT(!class_d.IsNull());
+ EXPECT(class_d.EnsureIsFinalized(thread) == Error::null());
const String& function_foo_name = String::Handle(String::New("foo"));
const String& function_bar_name = String::Handle(String::New("bar"));
@@ -74,7 +77,7 @@
Function::Handle(class_d.LookupDynamicFunction(function_bar_name));
EXPECT(!class_d_bar.IsNull());
- CHA cha(Thread::Current());
+ CHA cha(thread);
EXPECT(cha.HasSubclasses(kInstanceCid));
EXPECT(!cha.HasSubclasses(kSmiCid));
diff --git a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
index 5ed4c10..ac59909 100644
--- a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
+++ b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
@@ -1058,7 +1058,9 @@
const auto& parent = Function::Handle(Z, function.parent_function());
const auto& func_name = String::Handle(Z, parent.name());
const auto& owner = Class::Handle(Z, parent.Owner());
- function = owner.LookupFunction(func_name);
+ if (owner.EnsureIsFinalized(thread_) == Error::null()) {
+ function = owner.LookupFunction(func_name);
+ }
}
Object& options = Object::Handle(Z);
diff --git a/runtime/vm/compiler/frontend/bytecode_reader.cc b/runtime/vm/compiler/frontend/bytecode_reader.cc
index 4d6eb95..69890d2 100644
--- a/runtime/vm/compiler/frontend/bytecode_reader.cc
+++ b/runtime/vm/compiler/frontend/bytecode_reader.cc
@@ -1452,7 +1452,10 @@
cls.raw() == scoped_function_class_.raw()) {
return scoped_function_.raw();
}
- FunctionPtr function = cls.LookupFunction(name);
+ FunctionPtr function = Function::null();
+ if (cls.EnsureIsFinalized(thread_) == Error::null()) {
+ function = cls.LookupFunction(name);
+ }
if (function == Function::null()) {
// When requesting a getter, also return method extractors.
if (Field::IsGetterName(name)) {
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
index 671deaf..c2d252c 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
@@ -2454,11 +2454,16 @@
return instructions;
}
-static Function& GetNoSuchMethodOrDie(Zone* zone, const Class& klass) {
+static Function& GetNoSuchMethodOrDie(Thread* thread,
+ Zone* zone,
+ const Class& klass) {
Function& nsm_function = Function::Handle(zone);
Class& iterate_klass = Class::Handle(zone, klass.raw());
while (!iterate_klass.IsNull()) {
- nsm_function = iterate_klass.LookupDynamicFunction(Symbols::NoSuchMethod());
+ if (iterate_klass.EnsureIsFinalized(thread) == Error::null()) {
+ nsm_function =
+ iterate_klass.LookupDynamicFunction(Symbols::NoSuchMethod());
+ }
if (!nsm_function.IsNull() && nsm_function.NumParameters() == 2 &&
nsm_function.NumTypeParameters() == 0) {
break;
@@ -2511,6 +2516,8 @@
const Class& mirror_class =
Class::Handle(Z, Library::LookupCoreClass(Symbols::InvocationMirror()));
ASSERT(!mirror_class.IsNull());
+ const auto& error = mirror_class.EnsureIsFinalized(thread());
+ ASSERT(error == Error::null());
const Function& allocation_function = Function::ZoneHandle(
Z, mirror_class.LookupStaticFunction(
Library::PrivateCoreLibName(Symbols::AllocateInvocationMirror())));
@@ -2544,17 +2551,19 @@
// method.
Function& function = Function::Handle(Z);
while (!klass.IsNull()) {
- function = klass.LookupDynamicFunction(method_name);
- if (!function.IsNull()) {
- Function& target =
- Function::ZoneHandle(Z, function.ImplicitClosureFunction());
- ASSERT(!target.IsNull());
- // Generate inline code for allocation closure object with context
- // which captures `this`.
- return BuildImplicitClosureCreation(target);
+ if (klass.EnsureIsFinalized(thread()) == Error::null()) {
+ function = klass.LookupDynamicFunction(method_name);
+ if (!function.IsNull()) {
+ Function& target =
+ Function::ZoneHandle(Z, function.ImplicitClosureFunction());
+ ASSERT(!target.IsNull());
+ // Generate inline code for allocation closure object with context
+ // which captures `this`.
+ return BuildImplicitClosureCreation(target);
+ }
+ function = klass.LookupDynamicFunction(getter_name);
+ if (!function.IsNull()) break;
}
- function = klass.LookupDynamicFunction(getter_name);
- if (!function.IsNull()) break;
klass = klass.SuperClass();
}
@@ -2575,7 +2584,7 @@
/* argument_names = */ Object::empty_array(), actuals_array,
/* build_rest_of_actuals = */ Fragment());
- Function& nsm_function = GetNoSuchMethodOrDie(Z, parent_klass);
+ Function& nsm_function = GetNoSuchMethodOrDie(thread(), Z, parent_klass);
instructions +=
StaticCall(position, Function::ZoneHandle(Z, nsm_function.raw()),
/* argument_count = */ 2, ICData::kNSMDispatch);
@@ -2603,8 +2612,10 @@
const String& setter_name = ReadNameAsSetterName(); // read name.
- Function& function =
- Function::Handle(Z, H.LookupDynamicFunction(klass, setter_name));
+ Function& function = Function::Handle(Z);
+ if (klass.EnsureIsFinalized(thread()) == Error::null()) {
+ function = H.LookupDynamicFunction(klass, setter_name);
+ }
Fragment instructions(MakeTemp());
LocalVariable* value = MakeTemporary(); // this holds RHS value
@@ -2631,7 +2642,7 @@
SkipInterfaceMemberNameReference(); // skip target_reference.
- Function& nsm_function = GetNoSuchMethodOrDie(Z, klass);
+ Function& nsm_function = GetNoSuchMethodOrDie(thread(), Z, klass);
instructions +=
StaticCall(position, Function::ZoneHandle(Z, nsm_function.raw()),
/* argument_count = */ 2, ICData::kNSMDispatch);
@@ -3219,7 +3230,7 @@
SkipInterfaceMemberNameReference(); // skip target_reference.
- Function& nsm_function = GetNoSuchMethodOrDie(Z, klass);
+ Function& nsm_function = GetNoSuchMethodOrDie(thread(), Z, klass);
instructions += StaticCall(TokenPosition::kNoSource,
Function::ZoneHandle(Z, nsm_function.raw()),
/* argument_count = */ 2, ICData::kNSMDispatch);
@@ -3858,9 +3869,11 @@
const Class& map_class =
Class::Handle(Z, Library::LookupCoreClass(Symbols::Map()));
- const Function& factory_method = Function::ZoneHandle(
- Z, map_class.LookupFactory(
- Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
+ Function& factory_method = Function::ZoneHandle(Z);
+ if (map_class.EnsureIsFinalized(H.thread()) == Error::null()) {
+ factory_method = map_class.LookupFactory(
+ Library::PrivateCoreLibName(Symbols::MapLiteralFactory()));
+ }
return instructions +
StaticCall(position, factory_method, 2, ICData::kStatic);
@@ -3964,6 +3977,8 @@
if (position != NULL) *position = TokenPosition::kNoSource;
const Class& future = Class::Handle(Z, I->object_store()->future_class());
ASSERT(!future.IsNull());
+ const auto& error = future.EnsureIsFinalized(thread());
+ ASSERT(error == Error::null());
const Function& constructor =
Function::ZoneHandle(Z, future.LookupFunction(Symbols::FutureValue()));
ASSERT(!constructor.IsNull());
@@ -4500,6 +4515,8 @@
const Class& klass = Class::ZoneHandle(
Z, Library::LookupCoreClass(Symbols::FallThroughError()));
ASSERT(!klass.IsNull());
+ const auto& error = klass.EnsureIsFinalized(thread());
+ ASSERT(error == Error::null());
GrowableHandlePtrArray<const String> pieces(Z, 3);
pieces.Add(Symbols::FallThroughError());
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 712deec..eae3173 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -444,6 +444,8 @@
Z, Library::LookupCoreClass(Symbols::LateInitializationError()));
ASSERT(!klass.IsNull());
+ const auto& error = klass.EnsureIsFinalized(thread_);
+ ASSERT(error == Error::null());
const Function& throw_new =
Function::ZoneHandle(Z, klass.LookupStaticFunctionAllowPrivate(
H.DartSymbolObfuscate("_throwNew")));
@@ -671,6 +673,8 @@
const Class& klass = Class::ZoneHandle(
Z, Library::LookupCoreClass(Symbols::NoSuchMethodError()));
ASSERT(!klass.IsNull());
+ const auto& error = klass.EnsureIsFinalized(H.thread());
+ ASSERT(error == Error::null());
const Function& throw_function = Function::ZoneHandle(
Z, klass.LookupStaticFunctionAllowPrivate(Symbols::ThrowNew()));
ASSERT(!throw_function.IsNull());
@@ -1552,6 +1556,8 @@
const Class& klass =
Class::ZoneHandle(Z, Library::LookupCoreClass(Symbols::AssertionError()));
ASSERT(!klass.IsNull());
+ const auto& error = klass.EnsureIsFinalized(H.thread());
+ ASSERT(error == Error::null());
const Function& target = Function::ZoneHandle(
Z, klass.LookupStaticFunctionAllowPrivate(Symbols::EvaluateAssertion()));
ASSERT(!target.IsNull());
@@ -1904,6 +1910,8 @@
const Class& mirror_class =
Class::Handle(Z, Library::LookupCoreClass(Symbols::InvocationMirror()));
ASSERT(!mirror_class.IsNull());
+ const auto& error = mirror_class.EnsureIsFinalized(H.thread());
+ ASSERT(error == Error::null());
const Function& allocation_function = Function::ZoneHandle(
Z, mirror_class.LookupStaticFunction(
Library::PrivateCoreLibName(Symbols::AllocateInvocationMirror())));
@@ -2637,6 +2645,8 @@
const Class& mirror_class =
Class::Handle(Z, Library::LookupCoreClass(Symbols::InvocationMirror()));
ASSERT(!mirror_class.IsNull());
+ const auto& error = mirror_class.EnsureIsFinalized(H.thread());
+ ASSERT(error == Error::null());
const Function& allocation_function = Function::ZoneHandle(
Z, mirror_class.LookupStaticFunction(Library::PrivateCoreLibName(
Symbols::AllocateInvocationMirrorForClosure())));
@@ -2648,6 +2658,8 @@
const Class& klass = Class::ZoneHandle(
Z, Library::LookupCoreClass(Symbols::NoSuchMethodError()));
ASSERT(!klass.IsNull());
+ const auto& error = klass.EnsureIsFinalized(H.thread());
+ ASSERT(error == Error::null());
const Function& throw_function = Function::ZoneHandle(
Z,
klass.LookupStaticFunctionAllowPrivate(Symbols::ThrowNewInvocation()));
@@ -3566,6 +3578,8 @@
const Class& klass = Class::ZoneHandle(
Z, Library::LookupCoreClass(Symbols::AssertionError()));
ASSERT(!klass.IsNull());
+ const auto& error = klass.EnsureIsFinalized(H.thread());
+ ASSERT(error == Error::null());
throw_new_null_assertion_ =
&Function::ZoneHandle(Z, klass.LookupStaticFunctionAllowPrivate(
Symbols::ThrowNewNullAssertion()));
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.cc b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
index 1785105..b185b81 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.cc
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
@@ -623,6 +623,8 @@
} else {
ASSERT(IsClass(enclosing));
Class& klass = Class::Handle(Z, LookupClassByKernelClass(enclosing));
+ const auto& error = klass.EnsureIsFinalized(thread_);
+ ASSERT(error == Error::null());
Function& function = Function::ZoneHandle(
Z, klass.LookupFunctionAllowPrivate(procedure_name));
CheckStaticLookup(function);
@@ -646,6 +648,8 @@
const Class& owner,
NameIndex constructor) {
ASSERT(IsConstructor(constructor));
+ const auto& error = owner.EnsureIsFinalized(thread_);
+ ASSERT(error == Error::null());
Function& function = Function::Handle(
Z, owner.LookupConstructorAllowPrivate(DartConstructorName(constructor)));
CheckStaticLookup(function);
@@ -663,6 +667,8 @@
String& new_name =
String::ZoneHandle(Z, Symbols::FromConcatAll(thread_, pieces));
+ const auto& error = owner.EnsureIsFinalized(thread_);
+ ASSERT(error == Error::null());
FunctionPtr function = owner.LookupConstructorAllowPrivate(new_name);
ASSERT(function != Object::null());
return function;
@@ -672,9 +678,10 @@
const String& method_name) {
NameIndex kernel_class = EnclosingName(target);
Class& klass = Class::Handle(Z, LookupClassByKernelClass(kernel_class));
-
- Function& function =
- Function::Handle(Z, klass.LookupFunctionAllowPrivate(method_name));
+ Function& function = Function::Handle(Z);
+ if (klass.EnsureIsFinalized(thread_) == Error::null()) {
+ function = klass.LookupFunctionAllowPrivate(method_name);
+ }
#ifdef DEBUG
if (function.IsNull()) {
THR_Print("Unable to find \'%s\' in %s\n", method_name.ToCString(),
diff --git a/runtime/vm/compiler_test.cc b/runtime/vm/compiler_test.cc
index fc900fa..219dc7c 100644
--- a/runtime/vm/compiler_test.cc
+++ b/runtime/vm/compiler_test.cc
@@ -36,6 +36,8 @@
Class& cls =
Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
EXPECT(!cls.IsNull());
+ const auto& error = cls.EnsureIsFinalized(thread);
+ EXPECT(error == Error::null());
String& function_foo_name = String::Handle(String::New("foo"));
Function& function_foo =
Function::Handle(cls.LookupStaticFunction(function_foo_name));
@@ -75,6 +77,8 @@
Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
EXPECT(!cls.IsNull());
String& function_foo_name = String::Handle(String::New("foo"));
+ const auto& error = cls.EnsureIsFinalized(thread);
+ EXPECT(error == Error::null());
Function& func =
Function::Handle(cls.LookupStaticFunction(function_foo_name));
EXPECT(!func.HasCode());
@@ -116,6 +120,8 @@
Class& cls =
Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
EXPECT(!cls.IsNull());
+ const auto& error = cls.EnsureIsFinalized(thread);
+ EXPECT(error == Error::null());
String& function_foo_name = String::Handle(String::New("foo"));
Function& func =
Function::Handle(cls.LookupStaticFunction(function_foo_name));
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index 95ae9bb..e867ce4 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -2828,6 +2828,11 @@
"cls_type must be a Type object which represents a Class");
}
+ const auto& error = klass.EnsureIsFinalized(Thread::Current());
+ if (error != Error::null()) {
+ return Api::NewHandle(T, error);
+ }
+
const String& func_name = Api::UnwrapStringHandle(Z, function_name);
if (func_name.IsNull()) {
RETURN_TYPE_ERROR(Z, function_name, String);
@@ -4330,8 +4335,10 @@
const String& constr_name,
int num_args) {
// The constructor must be present in the interface.
- const Function& constructor =
- Function::Handle(cls.LookupFunctionAllowPrivate(constr_name));
+ Function& constructor = Function::Handle();
+ if (cls.EnsureIsFinalized(Thread::Current()) == Error::null()) {
+ constructor = cls.LookupFunctionAllowPrivate(constr_name);
+ }
if (constructor.IsNull() ||
(!constructor.IsGenerativeConstructor() && !constructor.IsFactory())) {
const String& lookup_class_name = String::Handle(cls.Name());
diff --git a/runtime/vm/dart_entry.cc b/runtime/vm/dart_entry.cc
index 8cb10d9..96081a8 100644
--- a/runtime/vm/dart_entry.cc
+++ b/runtime/vm/dart_entry.cc
@@ -335,6 +335,9 @@
Class& invocation_mirror_class = Class::Handle(core_lib.LookupClass(
String::Handle(core_lib.PrivateName(Symbols::InvocationMirror()))));
ASSERT(!invocation_mirror_class.IsNull());
+ Thread* thread = Thread::Current();
+ const auto& error = invocation_mirror_class.EnsureIsFinalized(thread);
+ ASSERT(error == Error::null());
const String& function_name =
String::Handle(core_lib.PrivateName(Symbols::AllocateInvocationMirror()));
const Function& allocation_function = Function::Handle(
@@ -363,7 +366,6 @@
if (function.IsNull()) {
ASSERT(!FLAG_lazy_dispatchers);
// If noSuchMethod(invocation) is not found, call Object::noSuchMethod.
- Thread* thread = Thread::Current();
function = Resolver::ResolveDynamicForReceiverClass(
Class::Handle(thread->zone(),
thread->isolate()->object_store()->object_class()),
@@ -643,6 +645,9 @@
const int kNumArguments = 1; // Receiver.
ArgumentsDescriptor args_desc(Array::Handle(
ArgumentsDescriptor::NewBoxed(kTypeArgsLen, kNumArguments)));
+ const Class& receiver_class = Class::Handle(receiver.clazz());
+ const auto& error = receiver_class.EnsureIsFinalized(Thread::Current());
+ ASSERT(error == Error::null());
const Function& function = Function::Handle(
Resolver::ResolveDynamic(receiver, Symbols::toString(), args_desc));
ASSERT(!function.IsNull());
diff --git a/runtime/vm/isolate.cc b/runtime/vm/isolate.cc
index 2ea406b..5f37ada 100644
--- a/runtime/vm/isolate.cc
+++ b/runtime/vm/isolate.cc
@@ -3991,8 +3991,11 @@
(library_url() != nullptr ? library_url() : script_url())));
return LanguageError::New(msg);
}
- const Function& func =
- Function::Handle(zone, cls.LookupStaticFunctionAllowPrivate(func_name));
+ Function& func = Function::Handle(zone);
+ const auto& error = cls.EnsureIsFinalized(thread);
+ if (error == Error::null()) {
+ func = cls.LookupStaticFunctionAllowPrivate(func_name);
+ }
if (func.IsNull()) {
const String& msg = String::Handle(
zone, String::NewFormatted(
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 25c9549..cc72376 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -3598,6 +3598,9 @@
const Function& closure_function =
Function::Handle(ImplicitClosureFunction());
const Class& owner = Class::Handle(closure_function.Owner());
+ if (owner.EnsureIsFinalized(Thread::Current()) != Error::null()) {
+ return Function::null();
+ }
Function& result = Function::Handle(owner.LookupDynamicFunction(getter_name));
if (result.IsNull()) {
result = CreateMethodExtractor(getter_name);
@@ -3947,10 +3950,13 @@
args.SetAt(6, argument_names);
const Library& libcore = Library::Handle(Library::CoreLibrary());
- const Class& NoSuchMethodError =
+ const Class& cls =
Class::Handle(libcore.LookupClass(Symbols::NoSuchMethodError()));
- const Function& throwNew = Function::Handle(
- NoSuchMethodError.LookupFunctionAllowPrivate(Symbols::ThrowNew()));
+ ASSERT(!cls.IsNull());
+ const auto& error = cls.EnsureIsFinalized(Thread::Current());
+ ASSERT(error == Error::null());
+ const Function& throwNew =
+ Function::Handle(cls.LookupFunctionAllowPrivate(Symbols::ThrowNew()));
return DartEntry::InvokeFunction(throwNew, args);
}
@@ -3966,10 +3972,12 @@
args.SetAt(3, dst_name);
const Library& libcore = Library::Handle(Library::CoreLibrary());
- const Class& TypeError =
+ const Class& cls =
Class::Handle(libcore.LookupClassAllowPrivate(Symbols::TypeError()));
- const Function& throwNew = Function::Handle(
- TypeError.LookupFunctionAllowPrivate(Symbols::ThrowNew()));
+ const auto& error = cls.EnsureIsFinalized(Thread::Current());
+ ASSERT(error == Error::null());
+ const Function& throwNew =
+ Function::Handle(cls.LookupFunctionAllowPrivate(Symbols::ThrowNew()));
return DartEntry::InvokeFunction(throwNew, args);
}
@@ -5337,9 +5345,7 @@
FunctionPtr Class::LookupFunction(const String& name, MemberKind kind) const {
ASSERT(!IsNull());
Thread* thread = Thread::Current();
- if (EnsureIsFinalized(thread) != Error::null()) {
- return Function::null();
- }
+ RELEASE_ASSERT(is_finalized());
REUSABLE_ARRAY_HANDLESCOPE(thread);
REUSABLE_FUNCTION_HANDLESCOPE(thread);
Array& funcs = thread->ArrayHandle();
@@ -5389,9 +5395,7 @@
MemberKind kind) const {
ASSERT(!IsNull());
Thread* thread = Thread::Current();
- if (EnsureIsFinalized(thread) != Error::null()) {
- return Function::null();
- }
+ RELEASE_ASSERT(is_finalized());
REUSABLE_ARRAY_HANDLESCOPE(thread);
REUSABLE_FUNCTION_HANDLESCOPE(thread);
REUSABLE_STRING_HANDLESCOPE(thread);
@@ -9033,6 +9037,8 @@
const auto& parent = Function::Handle(zone, parent_function());
const auto& func_name = String::Handle(zone, parent.name());
const auto& owner = Class::Handle(zone, parent.Owner());
+ const auto& error = owner.EnsureIsFinalized(Thread::Current());
+ ASSERT(error == Error::null());
auto& target = Function::Handle(zone, owner.LookupFunction(func_name));
if (!target.IsNull() && (target.raw() != parent.raw())) {
@@ -13974,11 +13980,13 @@
class_str = String::New(class_name);
cls = lib.LookupClassAllowPrivate(class_str);
if (!cls.IsNull()) {
- func_str = String::New(function_name);
- if (function_name[0] == '.') {
- func_str = String::Concat(class_str, func_str);
+ if (cls.EnsureIsFinalized(thread) == Error::null()) {
+ func_str = String::New(function_name);
+ if (function_name[0] == '.') {
+ func_str = String::Concat(class_str, func_str);
+ }
+ func = cls.LookupFunctionAllowPrivate(func_str);
}
- func = cls.LookupFunctionAllowPrivate(func_str);
}
}
if (!func.IsNull()) {
diff --git a/runtime/vm/object_store.cc b/runtime/vm/object_store.cc
index 26a5c3a..37b39ac 100644
--- a/runtime/vm/object_store.cc
+++ b/runtime/vm/object_store.cc
@@ -191,6 +191,8 @@
const Library& core_lib = Library::Handle(core_library());
const String& mangled = String::ZoneHandle(core_lib.PrivateName(name));
const Class& cls = Class::Handle(object_class());
+ const auto& error = cls.EnsureIsFinalized(Thread::Current());
+ ASSERT(error == Error::null());
const Function& result = Function::Handle(cls.LookupDynamicFunction(mangled));
ASSERT(!result.IsNull());
return result.raw();
diff --git a/runtime/vm/object_test.cc b/runtime/vm/object_test.cc
index 2d3b16e..68f2de9 100644
--- a/runtime/vm/object_test.cc
+++ b/runtime/vm/object_test.cc
@@ -3709,6 +3709,8 @@
}
static FunctionPtr GetFunction(const Class& cls, const char* name) {
+ const auto& error = cls.EnsureIsFinalized(Thread::Current());
+ EXPECT(error == Error::null());
const Function& result = Function::Handle(
cls.LookupDynamicFunction(String::Handle(String::New(name))));
EXPECT(!result.IsNull());
@@ -3716,6 +3718,8 @@
}
static FunctionPtr GetStaticFunction(const Class& cls, const char* name) {
+ const auto& error = cls.EnsureIsFinalized(Thread::Current());
+ EXPECT(error == Error::null());
const Function& result = Function::Handle(
cls.LookupStaticFunction(String::Handle(String::New(name))));
EXPECT(!result.IsNull());
diff --git a/runtime/vm/runtime_entry.cc b/runtime/vm/runtime_entry.cc
index a17e9c6..cf921ac 100644
--- a/runtime/vm/runtime_entry.cc
+++ b/runtime/vm/runtime_entry.cc
@@ -1373,9 +1373,11 @@
ASSERT(function_name.IsSymbol());
const Class& receiver_class = Class::Handle(zone, receiver.clazz());
- Function& target_function = Function::Handle(
- zone, Resolver::ResolveDynamicForReceiverClass(
- receiver_class, function_name, arguments_descriptor));
+ Function& target_function = Function::Handle(zone);
+ if (receiver_class.EnsureIsFinalized(thread) == Error::null()) {
+ target_function = Resolver::ResolveDynamicForReceiverClass(
+ receiver_class, function_name, arguments_descriptor);
+ }
ObjectStore* store = thread->isolate()->object_store();
if (target_function.raw() == store->simple_instance_of_function()) {
@@ -1742,16 +1744,19 @@
}
#endif // !defined(DART_PRECOMPILED_RUNTIME)
-static FunctionPtr Resolve(Zone* zone,
+static FunctionPtr Resolve(Thread* thread,
+ Zone* zone,
const Class& receiver_class,
const String& name,
const Array& descriptor) {
ASSERT(name.IsSymbol());
ArgumentsDescriptor args_desc(descriptor);
- Function& target_function =
- Function::Handle(zone, Resolver::ResolveDynamicForReceiverClass(
- receiver_class, name, args_desc));
+ Function& target_function = Function::Handle(zone);
+ if (receiver_class.EnsureIsFinalized(thread) == Error::null()) {
+ target_function = Resolver::ResolveDynamicForReceiverClass(receiver_class,
+ name, args_desc);
+ }
if (target_function.IsNull()) {
target_function = InlineCacheMissHelper(receiver_class, descriptor, name);
@@ -1777,7 +1782,8 @@
const auto& old_receiver_class =
Class::Handle(zone_, isolate_->class_table()->At(old_expected_cid));
const auto& old_target = Function::Handle(
- zone_, Resolve(zone_, old_receiver_class, name_, args_descriptor_));
+ zone_,
+ Resolve(thread_, zone_, old_receiver_class, name_, args_descriptor_));
const ICData& ic_data = ICData::Handle(
zone_, ICData::New(caller_function_, name_, args_descriptor_,
@@ -2052,7 +2058,7 @@
UNREACHABLE();
}
const Class& cls = Class::Handle(zone_, receiver_.clazz());
- return Resolve(zone_, cls, name_, args_descriptor_);
+ return Resolve(thread_, zone_, cls, name_, args_descriptor_);
}
void SwitchableCallHandler::HandleMiss(const Object& old_data,
@@ -2169,15 +2175,17 @@
const Array& arg_desc = Array::CheckedHandle(zone, arguments.ArgAt(2));
ArgumentsDescriptor arguments_descriptor(arg_desc);
- Function& target_function = Function::Handle(
- zone,
- Resolver::ResolveDynamic(receiver, target_name, arguments_descriptor));
+ const Class& receiver_class = Class::Handle(zone, receiver.clazz());
+ Function& target_function = Function::Handle(zone);
+ if (receiver_class.EnsureIsFinalized(thread) == Error::null()) {
+ target_function =
+ Resolver::ResolveDynamic(receiver, target_name, arguments_descriptor);
+ }
// TODO(regis): In order to substitute 'simple_instance_of_function', the 2nd
// arg to the call, the type, is needed.
if (target_function.IsNull()) {
- const Class& receiver_class = Class::Handle(zone, receiver.clazz());
target_function =
InlineCacheMissHelper(receiver_class, arg_desc, target_name);
}
@@ -2190,6 +2198,7 @@
// invoking noSuchMethod when lazy dispatchers are disabled. Returns the
// result of the invocation or an Error.
static ObjectPtr InvokeCallThroughGetterOrNoSuchMethod(
+ Thread* thread,
Zone* zone,
const Instance& receiver,
const String& target_name,
@@ -2222,7 +2231,9 @@
// We don't generate dyn:* forwarders for method extractors so there is no
// need to try to find a dyn:get:foo first (see assertion below)
if (function.IsNull()) {
- function = cls.LookupDynamicFunction(function_name);
+ if (cls.EnsureIsFinalized(thread) == Error::null()) {
+ function = cls.LookupDynamicFunction(function_name);
+ }
}
if (!function.IsNull()) {
#if !defined(DART_PRECOMPILED_RUNTIME)
@@ -2280,7 +2291,9 @@
while (!cls.IsNull()) {
// If there is a function with the target name but mismatched arguments
// we need to call `receiver.noSuchMethod()`.
- function = cls.LookupDynamicFunction(target_name);
+ if (cls.EnsureIsFinalized(thread) == Error::null()) {
+ function = cls.LookupDynamicFunction(target_name);
+ }
if (!function.IsNull()) {
ASSERT(!function.AreValidArguments(args_desc, NULL));
break; // mismatch, invoke noSuchMethod
@@ -2359,10 +2372,10 @@
target_name = MegamorphicCache::Cast(ic_data_or_cache).target_name();
}
- const auto& result = Object::Handle(
- zone,
- InvokeCallThroughGetterOrNoSuchMethod(
- zone, receiver, target_name, orig_arguments, orig_arguments_desc));
+ const auto& result =
+ Object::Handle(zone, InvokeCallThroughGetterOrNoSuchMethod(
+ thread, zone, receiver, target_name,
+ orig_arguments, orig_arguments_desc));
ThrowIfError(result);
arguments.SetReturn(result);
}
@@ -2417,7 +2430,7 @@
// Failing to find the method could be due to the lack of lazy invoke field
// dispatchers, so attempt a deeper search before calling noSuchMethod.
result = InvokeCallThroughGetterOrNoSuchMethod(
- zone, receiver, original_function_name, orig_arguments,
+ thread, zone, receiver, original_function_name, orig_arguments,
orig_arguments_desc);
} else {
result = DartEntry::InvokeNoSuchMethod(receiver, original_function_name,
diff --git a/tools/VERSION b/tools/VERSION
index 56495e1..f256226 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 10
PATCH 0
-PRERELEASE 48
+PRERELEASE 49
PRERELEASE_PATCH 0
\ No newline at end of file
