[vm] Remove MixinAppType VM class and VM code supporting type resolution.
In Dart2, mixin application classes are generated by kernel and type resolution
is performed by kernel. In Dart1, using the VM parser, these tasks were done
during class and type finalization.
Change-Id: I927b1446d906ffd76ed9591c96e0d974df09f3bf
Reviewed-on: https://dart-review.googlesource.com/c/87025
Commit-Queue: Régis Crelier <regis@google.com>
Reviewed-by: Ryan Macnak <rmacnak@google.com>
diff --git a/pkg/front_end/testcases/legacy.status b/pkg/front_end/testcases/legacy.status
index aa3139e..4680b00 100644
--- a/pkg/front_end/testcases/legacy.status
+++ b/pkg/front_end/testcases/legacy.status
@@ -29,6 +29,7 @@
inference/unsafe_block_closure_inference_function_call_explicit_type_param_via_expr2: RuntimeError
instantiate_to_bound/body_typedef_super_bounded_type: Fail # Issue 33444
instantiate_to_bound/non_simple_class_parametrized_typedef_cycle: RuntimeError # May be related to Issue 33479
+instantiate_to_bound/non_simple_generic_function_in_bound_regress: RuntimeError # Expected
instantiate_to_bound/typedef_super_bounded_type: Fail # Issue 33444
invocations: Fail
micro: Fail # External method marked abstract.
@@ -113,6 +114,7 @@
regress/issue_35259: RuntimeError # Expected
regress/issue_35260: RuntimeError # Expected
regress/issue_35266: RuntimeError # Expected
+reject_generic_function_types_in_bounds: RuntimeError # Expected
runtime_checks/implicit_downcast_constructor_initializer: RuntimeError # Test exercises strong mode semantics
runtime_checks/implicit_downcast_do: RuntimeError # Test exercises strong mode semantics
runtime_checks/implicit_downcast_for_condition: RuntimeError # Test exercises strong mode semantics
diff --git a/pkg/front_end/testcases/strong.status b/pkg/front_end/testcases/strong.status
index 91dfdd9..11db99d 100644
--- a/pkg/front_end/testcases/strong.status
+++ b/pkg/front_end/testcases/strong.status
@@ -66,6 +66,8 @@
inference_new/infer_field_getter_setter_mismatch: TypeCheckError
inference_new/infer_field_override_getter_overrides_setter: TypeCheckError
inference_new/invalid_assignment_during_toplevel_inference: TypeCheckError
+instantiate_to_bound/non_simple_generic_function_in_bound_regress: RuntimeError # Expected
+instantiate_to_bound/non_simple_class_parametrized_typedef_cycle: RuntimeError # Expected
invalid_type: TypeCheckError
invocations: RuntimeError
issue34899: TypeCheckError
@@ -139,6 +141,7 @@
regress/issue_35259: RuntimeError # Expected
regress/issue_35260: RuntimeError # Expected
regress/issue_35266: RuntimeError # Expected
+reject_generic_function_types_in_bounds: RuntimeError # Expected
runtime_checks_new/contravariant_generic_return_with_compound_assign_implicit_downcast: RuntimeError
runtime_checks_new/mixin_forwarding_stub_field: TypeCheckError
runtime_checks_new/mixin_forwarding_stub_getter: TypeCheckError
diff --git a/runtime/lib/mirrors.cc b/runtime/lib/mirrors.cc
index 37756f2..d4916d0 100644
--- a/runtime/lib/mirrors.cc
+++ b/runtime/lib/mirrors.cc
@@ -316,24 +316,16 @@
return CreateTypedefMirror(cls, type, is_declaration, owner_mirror);
}
- const Array& args = Array::Handle(Array::New(10));
+ const Array& args = Array::Handle(Array::New(9));
args.SetAt(0, MirrorReference::Handle(MirrorReference::New(cls)));
args.SetAt(1, type);
- // Note that the VM does not consider mixin application aliases to be mixin
- // applications, so this only covers anonymous mixin applications. We do not
- // set the names of anonymous mixin applications here because the mirrors
- // use a different naming convention than the VM (lib.S with lib.M and S&M
- // respectively).
- if (!cls.IsMixinApplication()) {
- args.SetAt(2, String::Handle(cls.Name()));
- }
+ args.SetAt(2, String::Handle(cls.Name()));
args.SetAt(3, owner_mirror);
args.SetAt(4, Bool::Get(cls.is_abstract()));
args.SetAt(5, Bool::Get(cls.IsGeneric()));
- args.SetAt(6, Bool::Get(cls.is_mixin_app_alias()));
- args.SetAt(7, Bool::Get(cls.is_transformed_mixin_application()));
- args.SetAt(8, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration);
- args.SetAt(9, Bool::Get(cls.is_enum_class()));
+ args.SetAt(6, Bool::Get(cls.is_transformed_mixin_application()));
+ args.SetAt(7, cls.NumTypeParameters() == 0 ? Bool::False() : is_declaration);
+ args.SetAt(8, Bool::Get(cls.is_enum_class()));
return CreateMirror(Symbols::_LocalClassMirror(), args);
}
@@ -930,8 +922,6 @@
if (cls.is_transformed_mixin_application()) {
const Array& interfaces = Array::Handle(cls.interfaces());
mixin_type ^= interfaces.At(interfaces.Length() - 1);
- } else {
- mixin_type = cls.mixin();
}
ASSERT(mixin_type.IsNull() || mixin_type.IsFinalized());
return mixin_type.raw();
@@ -947,8 +937,6 @@
if (cls.is_transformed_mixin_application()) {
const Array& interfaces = Array::Handle(cls.interfaces());
mixin_type ^= interfaces.At(interfaces.Length() - 1);
- } else {
- mixin_type = cls.mixin();
}
if (mixin_type.IsNull()) {
return mixin_type.raw();
@@ -1057,11 +1045,9 @@
entry = entries.GetNext();
if (entry.IsClass()) {
const Class& klass = Class::Cast(entry);
- // We filter out mixin application classes and dynamic.
+ // We filter out dynamic.
// TODO(12478): Should not need to filter out dynamic.
- // Note that the VM does not consider mixin application aliases to be
- // mixin applications.
- if (!klass.IsDynamicClass() && !klass.IsMixinApplication()) {
+ if (!klass.IsDynamicClass()) {
type = klass.DeclarationType();
member_mirror = CreateClassMirror(klass, type,
Bool::True(), // is_declaration
@@ -1347,7 +1333,8 @@
Class& redirected_klass = Class::Handle(klass.raw());
Function& redirected_constructor = Function::Handle(lookup_constructor.raw());
if (lookup_constructor.IsRedirectingFactory()) {
- ClassFinalizer::ResolveRedirectingFactory(klass, lookup_constructor);
+ // Redirecting factory must be resolved.
+ ASSERT(lookup_constructor.RedirectionTarget() != Function::null());
Type& redirect_type = Type::Handle(lookup_constructor.RedirectionType());
if (!redirect_type.IsInstantiated()) {
@@ -1548,8 +1535,7 @@
} else if (decl.IsClass()) {
const Class& cls = Class::Cast(decl);
const bool is_typedef = cls.IsTypedefClass();
- if (cls.is_synthesized_class() && !is_typedef &&
- !cls.is_mixin_app_alias() && !cls.is_enum_class()) {
+ if (cls.is_synthesized_class() && !is_typedef && !cls.is_enum_class()) {
return Instance::null(); // Synthetic.
}
script = cls.script();
diff --git a/runtime/lib/mirrors_impl.dart b/runtime/lib/mirrors_impl.dart
index 902e7ff..b11223b 100644
--- a/runtime/lib/mirrors_impl.dart
+++ b/runtime/lib/mirrors_impl.dart
@@ -368,10 +368,6 @@
final bool isAbstract;
final bool _isGeneric;
- // Only used for Dart 1 named mixin applications.
- // TODO(alexmarkov): Clean up after Dart 1 is gone.
- final bool _isMixinAlias;
-
// Since Dart 2, mixins are erased by kernel transformation.
// Resulting classes have this flag set, and mixed-in type is pulled into
// the end of interfaces list.
@@ -388,7 +384,6 @@
this._owner,
this.isAbstract,
this._isGeneric,
- this._isMixinAlias,
this._isTransformedMixinApplication,
this._isGenericDeclaration,
this.isEnum)
@@ -455,7 +450,7 @@
}
ClassMirror get superclass {
- return _isMixinAlias ? _trueSuperclass._trueSuperclass : _trueSuperclass;
+ return _trueSuperclass;
}
var _superinterfaces;
@@ -492,19 +487,13 @@
var _mixin;
ClassMirror get mixin {
if (_mixin == null) {
- if (_isMixinAlias) {
- Type mixinType = _nativeMixinInstantiated(
- _trueSuperclass._reflectedType, _instantiator);
- _mixin = reflectType(mixinType);
+ Type mixinType =
+ _nativeMixinInstantiated(_reflectedType, _instantiator);
+ if (mixinType == null) {
+ // The reflectee is not a mixin application.
+ _mixin = this;
} else {
- Type mixinType =
- _nativeMixinInstantiated(_reflectedType, _instantiator);
- if (mixinType == null) {
- // The reflectee is not a mixin application.
- _mixin = this;
- } else {
- _mixin = reflectType(mixinType);
- }
+ _mixin = reflectType(mixinType);
}
}
return _mixin;
@@ -572,9 +561,8 @@
var decls = new Map<Symbol, DeclarationMirror>();
- var whoseMembers = _isMixinAlias ? _trueSuperclass : this;
var members = (mixin as _LocalClassMirror)._computeMembers(
- _instantiator, (whoseMembers.mixin as _LocalClassMirror)._reflectee);
+ _instantiator, (mixin as _LocalClassMirror)._reflectee);
for (var member in members) {
decls[member.simpleName] = member;
}
@@ -596,7 +584,6 @@
// Note: returns correct result only for Dart 1 anonymous mixin applications.
bool get _isAnonymousMixinApplication {
- if (_isMixinAlias) return false; // Named mixin application.
if (mixin == this) return false; // Not a mixin application.
return true;
}
@@ -760,7 +747,7 @@
final _functionReflectee;
_LocalFunctionTypeMirror(reflectee, this._functionReflectee, reflectedType)
: super(reflectee, reflectedType, null, null, false, false, false, false,
- false, false);
+ false);
bool get _isAnonymousMixinApplication => false;
diff --git a/runtime/lib/type_patch.dart b/runtime/lib/type_patch.dart
index 21fac26..a05ce70 100644
--- a/runtime/lib/type_patch.dart
+++ b/runtime/lib/type_patch.dart
@@ -25,7 +25,3 @@
// Equivalent of RawTypeParameter.
@pragma("vm:entry-point")
class _TypeParameter extends _AbstractType {}
-
-// Equivalent of RawMixinAppType.
-@pragma("vm:entry-point")
-class _MixinAppType extends _AbstractType {}
diff --git a/runtime/observatory/tests/service/get_version_rpc_test.dart b/runtime/observatory/tests/service/get_version_rpc_test.dart
index dc2c129..9b1fb1a 100644
--- a/runtime/observatory/tests/service/get_version_rpc_test.dart
+++ b/runtime/observatory/tests/service/get_version_rpc_test.dart
@@ -12,7 +12,7 @@
var result = await vm.invokeRpcNoUpgrade('getVersion', {});
expect(result['type'], equals('Version'));
expect(result['major'], equals(3));
- expect(result['minor'], equals(12));
+ expect(result['minor'], equals(13));
expect(result['_privateMajor'], equals(0));
expect(result['_privateMinor'], equals(0));
},
diff --git a/runtime/vm/class_finalizer.cc b/runtime/vm/class_finalizer.cc
index 8d9ea57..fd69a3d 100644
--- a/runtime/vm/class_finalizer.cc
+++ b/runtime/vm/class_finalizer.cc
@@ -192,11 +192,11 @@
class_array = object_store->pending_classes();
ASSERT(!class_array.IsNull());
Class& cls = Class::Handle();
- // First resolve all superclasses.
+ // First check all superclasses.
for (intptr_t i = 0; i < class_array.Length(); i++) {
cls ^= class_array.At(i);
GrowableArray<intptr_t> visited_interfaces;
- ResolveSuperTypeAndInterfaces(cls, &visited_interfaces);
+ CheckSuperTypeAndInterfaces(cls, &visited_interfaces);
}
// Finalize all classes.
for (intptr_t i = 0; i < class_array.Length(); i++) {
@@ -223,22 +223,6 @@
return true;
}
-// Adds all interfaces of cls into 'collected'. Duplicate entries may occur.
-// No cycles are allowed.
-void ClassFinalizer::CollectInterfaces(const Class& cls,
- GrowableArray<const Class*>* collected) {
- Zone* zone = Thread::Current()->zone();
- const Array& interface_array = Array::Handle(zone, cls.interfaces());
- AbstractType& interface = AbstractType::Handle(zone);
- Class& interface_class = Class::Handle(zone);
- for (intptr_t i = 0; i < interface_array.Length(); i++) {
- interface ^= interface_array.At(i);
- interface_class = interface.type_class();
- collected->Add(&Class::ZoneHandle(zone, interface_class.raw()));
- CollectInterfaces(interface_class, collected);
- }
-}
-
#if !defined(DART_PRECOMPILED_RUNTIME)
void ClassFinalizer::VerifyBootstrapClasses() {
if (FLAG_trace_class_finalization) {
@@ -307,220 +291,12 @@
}
#endif // !defined(DART_PRECOMPILED_RUNTIME)
-void ClassFinalizer::ResolveRedirectingFactory(const Class& cls,
- const Function& factory) {
- const Function& target = Function::Handle(factory.RedirectionTarget());
- if (target.IsNull()) {
- Type& type = Type::Handle(factory.RedirectionType());
- const GrowableObjectArray& visited_factories =
- GrowableObjectArray::Handle(GrowableObjectArray::New());
- ResolveRedirectingFactoryTarget(cls, factory, visited_factories);
- if (factory.is_const()) {
- type = factory.RedirectionType();
- }
- }
-}
-
-void ClassFinalizer::ResolveRedirectingFactoryTarget(
- const Class& cls,
- const Function& factory,
- const GrowableObjectArray& visited_factories) {
- ASSERT(factory.IsRedirectingFactory());
-
- // Check for redirection cycle.
- for (intptr_t i = 0; i < visited_factories.Length(); i++) {
- if (visited_factories.At(i) == factory.raw()) {
- // A redirection cycle is reported as a compile-time error.
- ReportError(cls, factory.token_pos(),
- "factory '%s' illegally redirects to itself",
- String::Handle(factory.name()).ToCString());
- }
- }
- visited_factories.Add(factory);
-
- // Check if target is already resolved.
- Type& type = Type::Handle(factory.RedirectionType());
- Function& target = Function::Handle(factory.RedirectionTarget());
- if (!target.IsNull()) {
- // Already resolved.
- return;
- }
-
- // Target is not resolved yet.
- if (FLAG_trace_class_finalization) {
- THR_Print("Resolving redirecting factory: %s\n",
- String::Handle(factory.name()).ToCString());
- }
- type ^= FinalizeType(cls, type);
- factory.SetRedirectionType(type);
- ASSERT(!type.IsTypeParameter()); // Resolved in parser.
- ASSERT(!type.IsDynamicType());
- const Class& target_class = Class::Handle(type.type_class());
- String& target_class_name = String::Handle(target_class.Name());
- String& target_name =
- String::Handle(String::Concat(target_class_name, Symbols::Dot()));
- const String& identifier = String::Handle(factory.RedirectionIdentifier());
- if (!identifier.IsNull()) {
- target_name = String::Concat(target_name, identifier);
- }
-
- // Verify that the target constructor of the redirection exists.
- target = target_class.LookupConstructor(target_name);
- if (target.IsNull()) {
- target = target_class.LookupFactory(target_name);
- }
- ASSERT(!target.IsNull());
- // Verify that the target is const if the redirecting factory is const.
- if (factory.is_const() && !target.is_const()) {
- ReportError(target_class, target.token_pos(),
- "constructor '%s' must be const as required by "
- "redirecting const factory '%s'",
- String::Handle(target.name()).ToCString(),
- String::Handle(factory.name()).ToCString());
- }
-
- // Update redirection data with resolved target.
- factory.SetRedirectionTarget(target);
- // Not needed anymore.
- factory.SetRedirectionIdentifier(Object::null_string());
- if (!target.IsRedirectingFactory()) {
- return;
- }
-
- // The target is itself a redirecting factory. Recursively resolve its own
- // target and update the current redirection data to point to the end target
- // of the redirection chain.
- ResolveRedirectingFactoryTarget(target_class, target, visited_factories);
- Type& target_type = Type::Handle(target.RedirectionType());
- Function& target_target = Function::Handle(target.RedirectionTarget());
- ASSERT(!target_target.IsNull());
- // If the target type refers to type parameters, substitute them with the
- // type arguments of the redirection type.
- if (!target_type.IsInstantiated()) {
- // We do not support generic constructors.
- ASSERT(target_type.IsInstantiated(kFunctions));
- const TypeArguments& type_args = TypeArguments::Handle(type.arguments());
- target_type ^= target_type.InstantiateFrom(
- type_args, Object::null_type_arguments(), kNoneFree, NULL, Heap::kOld);
- }
- factory.SetRedirectionType(target_type);
- factory.SetRedirectionTarget(target_target);
-}
-
-void ClassFinalizer::ResolveTypeClass(const Class& cls, const Type& type) {
- if (type.IsFinalized()) {
- return;
- }
- if (FLAG_trace_type_finalization) {
- THR_Print("Resolve type class of '%s'\n",
- String::Handle(type.Name()).ToCString());
- }
-
- // Type parameters are always resolved in the parser in the correct
- // non-static scope or factory scope. That resolution scope is unknown here.
- // Being able to resolve a type parameter from class cls here would indicate
- // that the type parameter appeared in a static scope. Leaving the type as
- // unresolved is the correct thing to do.
-
- // Lookup the type class if necessary.
- Class& type_class = Class::Handle(type.type_class());
- // Promote the type to a function type in case its type class is a typedef.
- // Note that the type may already be a function type if it was parsed as a
- // formal parameter function type.
- if (!type.IsFunctionType() && type_class.IsTypedefClass()) {
- type.set_signature(Function::Handle(type_class.signature_function()));
- }
- ASSERT(!type_class.IsTypedefClass() ||
- (type.signature() != Function::null()));
-}
-
-void ClassFinalizer::ResolveType(const Class& cls, const AbstractType& type) {
- if (type.IsResolved()) {
- return;
- }
- if (FLAG_trace_type_finalization) {
- THR_Print("Resolve type '%s'\n", String::Handle(type.Name()).ToCString());
- }
- if (type.IsType()) {
- ResolveTypeClass(cls, Type::Cast(type));
- }
- // Mark type as resolved before resolving its type arguments and, in case of a
- // function type, its signature, in order to avoid cycles.
- type.SetIsResolved();
- // Resolve type arguments, if any.
- const TypeArguments& arguments = TypeArguments::Handle(type.arguments());
- if (!arguments.IsNull()) {
- const intptr_t num_arguments = arguments.Length();
- AbstractType& type_argument = AbstractType::Handle();
- for (intptr_t i = 0; i < num_arguments; i++) {
- type_argument = arguments.TypeAt(i);
- ResolveType(cls, type_argument);
- }
- }
- // Resolve signature if function type.
- if (type.IsFunctionType()) {
- const Function& signature = Function::Handle(Type::Cast(type).signature());
- Type& signature_type = Type::Handle(signature.SignatureType());
- if (signature_type.raw() != type.raw()) {
- // This type was promoted to a function type because its type class is a
- // typedef class. The promotion is achieved by assigning the signature
- // function of the typedef class to this type. This function is pointing
- // to the original typedef function type, which is not this type.
- // By resolving the typedef function type (which may already be resolved,
- // hence saving work), we will resolve the shared signature function.
- ASSERT(Class::Handle(type.type_class()).IsTypedefClass());
- ResolveType(cls, signature_type);
- } else {
- const Class& scope_class = Class::Handle(type.type_class());
- if (scope_class.IsTypedefClass()) {
- // This type is the original function type of the typedef class.
- ResolveSignature(scope_class, signature);
- } else {
- ASSERT(scope_class.IsClosureClass());
- ResolveSignature(cls, signature);
- ASSERT(type.arguments() == TypeArguments::null());
- if (signature.IsSignatureFunction()) {
- // Drop fields that are not necessary anymore after resolution.
- // The parent function, owner, and token position of a shared
- // canonical function type are meaningless, since the canonical
- // representent is picked arbitrarily.
- // The parent function is however still required to finalize function
- // type parameters when the function has a generic parent.
- if (!signature.HasGenericParent()) {
- signature.set_parent_function(Function::Handle());
- }
- // TODO(regis): As long as we support metadata in typedef signatures,
- // we cannot reset these fields used to reparse a typedef.
- // Note that the scope class of a typedef function type is always
- // preserved as the typedef class (not reset to _Closure class),
- // thereby preventing sharing of canonical function types between
- // typedefs. Not being shared, these fields are therefore always
- // meaningful for typedefs.
- if (!scope_class.IsTypedefClass()) {
- signature.set_owner(Object::Handle());
- signature.set_token_pos(TokenPosition::kNoSource);
- }
- }
- }
- }
- }
-
- // After resolving, we re-initialize the type testing stub.
- type.SetTypeTestingStub(
- Instructions::Handle(TypeTestingStubGenerator::DefaultCodeForType(type)));
-}
-
void ClassFinalizer::FinalizeTypeParameters(const Class& cls,
PendingTypes* pending_types) {
if (FLAG_trace_type_finalization) {
THR_Print("Finalizing type parameters of '%s'\n",
String::Handle(cls.Name()).ToCString());
}
- if (cls.IsMixinApplication()) {
- // Setup the type parameters of the mixin application and finalize the
- // mixin type.
- ApplyMixinType(cls, pending_types);
- }
// The type parameter bounds are not finalized here.
const TypeArguments& type_parameters =
TypeArguments::Handle(cls.type_parameters());
@@ -627,15 +403,11 @@
const AbstractType& type,
PendingTypes* pending_types) {
Zone* zone = Thread::Current()->zone();
- // The type class does not need to be finalized in order to finalize the type,
- // however, it must at least be resolved (this was done as part of resolving
- // the type itself, a precondition to calling FinalizeType).
- // Also, the interfaces of the type class must be resolved and the type
- // parameters of the type class must be finalized.
+ // The type class does not need to be finalized in order to finalize the type.
+ // Also, the type parameters of the type class must be finalized.
Class& type_class = Class::Handle(zone, type.type_class());
if (!type_class.is_type_finalized()) {
FinalizeTypeParameters(type_class, pending_types);
- ResolveUpperBounds(type_class);
}
// The finalized type argument vector needs num_type_arguments types.
@@ -778,7 +550,6 @@
ASSERT(arguments.Length() >= cls.NumTypeArguments());
if (!cls.is_type_finalized()) {
FinalizeTypeParameters(cls, pending_types);
- ResolveUpperBounds(cls);
}
AbstractType& super_type = AbstractType::Handle(cls.super_type());
if (!super_type.IsNull()) {
@@ -917,7 +688,6 @@
ASSERT(!type.IsBeingFinalized());
Zone* zone = Thread::Current()->zone();
- ResolveType(cls, type);
if (FLAG_trace_type_finalization) {
THR_Print("Finalizing type '%s' for class '%s'\n",
@@ -944,14 +714,8 @@
ASSERT(!function.IsNull());
offset = function.NumParentTypeParameters();
}
- // Calling NumTypeParameters() may finalize this type parameter if it
- // belongs to a mixin application class.
- if (!type_parameter.IsFinalized()) {
- type_parameter.set_index(type_parameter.index() + offset);
- type_parameter.SetIsFinalized();
- } else {
- ASSERT(cls.IsMixinApplication());
- }
+ type_parameter.set_index(type_parameter.index() + offset);
+ type_parameter.SetIsFinalized();
if (FLAG_trace_type_finalization) {
THR_Print("Done finalizing type parameter '%s' with index %" Pd "\n",
@@ -1056,46 +820,6 @@
}
}
-void ClassFinalizer::ResolveSignature(const Class& cls,
- const Function& function) {
- AbstractType& type = AbstractType::Handle();
- // Resolve upper bounds of function type parameters.
- const intptr_t num_type_params = function.NumTypeParameters();
- if (num_type_params > 0) {
- TypeParameter& type_param = TypeParameter::Handle();
- const TypeArguments& type_params =
- TypeArguments::Handle(function.type_parameters());
- for (intptr_t i = 0; i < num_type_params; i++) {
- type_param ^= type_params.TypeAt(i);
- type = type_param.bound();
- ResolveType(cls, type);
- if (type.IsFunctionType()) {
- const Function& signature_function =
- Function::Handle(Type::Cast(type).signature());
- if (signature_function.IsGeneric()) {
- const String& type_name = String::Handle(type.UserVisibleName());
- const String& type_param_name = String::Handle(type_param.name());
- ReportError(cls, type.token_pos(),
- "generic function type '%s' not allowed as bound of "
- "function type parameter '%s'",
- type_name.ToCString(), type_param_name.ToCString());
- }
- }
- }
- }
- // Resolve result type.
- type = function.result_type();
- // It is not a compile time error if this name does not resolve to a class or
- // interface.
- ResolveType(cls, type);
- // Resolve formal parameter types.
- const intptr_t num_parameters = function.NumParameters();
- for (intptr_t i = 0; i < num_parameters; i++) {
- type = function.ParameterTypeAt(i);
- ResolveType(cls, type);
- }
-}
-
void ClassFinalizer::FinalizeSignature(const Class& cls,
const Function& function,
FinalizationKind finalization) {
@@ -1140,36 +864,6 @@
}
}
-// Resolve the upper bounds of the type parameters of class cls.
-void ClassFinalizer::ResolveUpperBounds(const Class& cls) {
- const intptr_t num_type_params = cls.NumTypeParameters();
- TypeParameter& type_param = TypeParameter::Handle();
- AbstractType& bound = AbstractType::Handle();
- const TypeArguments& type_params =
- TypeArguments::Handle(cls.type_parameters());
- ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
- (type_params.Length() == num_type_params));
- // In a first pass, resolve all bounds. This guarantees that finalization
- // of mutually referencing bounds will not encounter an unresolved bound.
- for (intptr_t i = 0; i < num_type_params; i++) {
- type_param ^= type_params.TypeAt(i);
- bound = type_param.bound();
- ResolveType(cls, bound);
- if (bound.IsFunctionType()) {
- const Function& signature_function =
- Function::Handle(Type::Cast(bound).signature());
- if (signature_function.IsGeneric()) {
- const String& bound_name = String::Handle(bound.UserVisibleName());
- const String& type_param_name = String::Handle(type_param.name());
- ReportError(cls, bound.token_pos(),
- "generic function type '%s' not allowed as bound of "
- "class type parameter '%s'",
- bound_name.ToCString(), type_param_name.ToCString());
- }
- }
- }
-}
-
// Finalize the upper bounds of the type parameters of class cls.
void ClassFinalizer::FinalizeUpperBounds(const Class& cls,
FinalizationKind finalization) {
@@ -1183,6 +877,18 @@
for (intptr_t i = 0; i < num_type_params; i++) {
type_param ^= type_params.TypeAt(i);
bound = type_param.bound();
+ if (bound.IsFunctionType()) {
+ const Function& signature_function =
+ Function::Handle(Type::Cast(bound).signature());
+ if (signature_function.IsGeneric()) {
+ const String& bound_name = String::Handle(bound.UserVisibleName());
+ const String& type_param_name = String::Handle(type_param.name());
+ ReportError(cls, bound.token_pos(),
+ "generic function type '%s' not allowed as bound of "
+ "class type parameter '%s'",
+ bound_name.ToCString(), type_param_name.ToCString());
+ }
+ }
// Bound may be finalized, but not canonical yet.
if (bound.IsCanonical() || bound.IsBeingFinalized()) {
// A bound involved in F-bounded quantification may form a cycle.
@@ -1212,7 +918,7 @@
}
#endif
-void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
+void ClassFinalizer::FinalizeMemberTypes(const Class& cls) {
// Note that getters and setters are explicitly listed as such in the list of
// functions of a class, so we do not need to consider fields as implicitly
// generating getters and setters.
@@ -1232,7 +938,7 @@
// - an instance field or instance getter conflicting with an inherited
// instance method.
- // Resolve type of fields and check for conflicts in super classes.
+ // Finalize type of fields and check for conflicts in super classes.
Isolate* isolate = Isolate::Current();
Zone* zone = Thread::Current()->zone();
Array& array = Array::Handle(zone, cls.fields());
@@ -1250,7 +956,7 @@
StaticTypeExactnessState::Unitialized());
}
}
- // Resolve function signatures and check for conflicts in super classes and
+ // Finalize function signatures and check for conflicts in super classes and
// interfaces.
array = cls.functions();
Function& function = Function::Handle(zone);
@@ -1263,11 +969,6 @@
}
if (function.is_static()) {
if (function.IsRedirectingFactory()) {
- // The function may be a still unresolved redirecting factory. Do not
- // yet try to resolve it in order to avoid cycles in class finalization.
- // However, the redirection type should be finalized.
- // If the redirection type is from a deferred library and is not
- // yet loaded, do not attempt to resolve.
Type& type = Type::Handle(zone, function.RedirectionType());
type ^= FinalizeType(cls, type);
function.SetRedirectionType(type);
@@ -1276,654 +977,6 @@
}
}
-// Clone the type parameters of the super class and of the mixin class of this
-// mixin application class and use them as the type parameters of this mixin
-// application class. Set the type arguments of the super type, of the mixin
-// type (as well as of the interface type, which is identical to the mixin type)
-// to refer to the respective type parameters of the mixin application class.
-// In other words, decorate this mixin application class with type parameters
-// that forward to the super type and mixin type (and interface type).
-// Example:
-// class S<T extends BT> { }
-// class M<T extends BT> { }
-// class C<E extends BE> extends S<E> with M<List<E>> { }
-// results in
-// class S&M<T`, T extends BT> extends S<T`> implements M<T> { }
-// class C<E extends BE> extends S&M<E, List<E>> { }
-// CloneMixinAppTypeParameters decorates class S&M with type parameters T` and
-// T, and use them as type arguments in S<T`> and M<T>.
-// Note that the bound BT on T of S is not applied to T` of S&M. However, the
-// bound BT on T of M is applied to T of S&M. See comments below.
-void ClassFinalizer::CloneMixinAppTypeParameters(const Class& mixin_app_class) {
- ASSERT(mixin_app_class.type_parameters() == TypeArguments::null());
- Thread* thread = Thread::Current();
- Zone* zone = thread->zone();
- const AbstractType& super_type =
- AbstractType::Handle(zone, mixin_app_class.super_type());
- ASSERT(super_type.IsResolved());
- const Class& super_class = Class::Handle(zone, super_type.type_class());
- const intptr_t num_super_type_params = super_class.NumTypeParameters();
- const Type& mixin_type = Type::Handle(zone, mixin_app_class.mixin());
- const Class& mixin_class = Class::Handle(zone, mixin_type.type_class());
- const intptr_t num_mixin_type_params = mixin_class.NumTypeParameters();
-
- // The mixin type (in raw form) should have been added to the interfaces
- // implemented by the mixin application class. This is necessary so that cycle
- // check works at compile time (type arguments are ignored) and so that
- // type tests work at runtime (by then, type arguments will have been set, see
- // below).
- ASSERT(mixin_app_class.interfaces() != Object::empty_array().raw());
-
- // If both the super type and the mixin type are non generic, the mixin
- // application class is non generic as well and we can skip type parameter
- // cloning.
- TypeArguments& instantiator = TypeArguments::Handle(zone);
- if ((num_super_type_params + num_mixin_type_params) > 0) {
- // If the last ampersand in the name of the mixin application class is
- // doubled, the same type parameters can propagate the type arguments to
- // the super type and to the mixin type.
- bool share_type_params = false;
- if (num_super_type_params == num_mixin_type_params) {
- const String& name = String::Handle(zone, mixin_app_class.Name());
- for (intptr_t i = name.Length() - 1; i > 0; --i) {
- if (name.CharAt(i) == '&') {
- if (name.CharAt(i - 1) == '&') {
- share_type_params = true;
- }
- break;
- }
- }
- }
-
- const TypeArguments& cloned_type_params = TypeArguments::Handle(
- zone,
- TypeArguments::New((share_type_params ? 0 : num_super_type_params) +
- num_mixin_type_params));
- TypeParameter& param = TypeParameter::Handle(zone);
- TypeParameter& cloned_param = TypeParameter::Handle(zone);
- String& param_name = String::Handle(zone);
- AbstractType& param_bound = AbstractType::Handle(zone);
- Function& null_function = Function::Handle(zone);
- intptr_t cloned_index = 0;
-
- // First, clone the super class type parameters. Rename them so that
- // there can be no name conflict between the parameters of the super
- // class and the mixin class.
- if (!share_type_params && (num_super_type_params > 0)) {
- const TypeArguments& super_type_params =
- TypeArguments::Handle(zone, super_class.type_parameters());
- const TypeArguments& super_type_args = TypeArguments::Handle(
- zone, TypeArguments::New(num_super_type_params));
- // The cloned super class type parameters do not need to repeat their
- // bounds, since the bound checks will be performed at the super class
- // level. As a consequence, if this mixin application is used itself as a
- // mixin in another mixin application, the bounds will be ignored, which
- // is correct, because the other mixin application does not inherit from
- // the super class of its mixin. Note also that the other mixin
- // application will only mixin the last mixin type listed in the first
- // mixin application it is mixing in.
- param_bound = thread->isolate()->object_store()->object_type();
- for (intptr_t i = 0; i < num_super_type_params; i++) {
- param ^= super_type_params.TypeAt(i);
- param_name = param.name();
- param_name =
- Symbols::FromConcat(thread, param_name, Symbols::Backtick());
- cloned_param =
- TypeParameter::New(mixin_app_class, null_function, cloned_index,
- param_name, param_bound, param.token_pos());
- cloned_type_params.SetTypeAt(cloned_index, cloned_param);
- // Change the type arguments of the super type to refer to the
- // cloned type parameters of the mixin application class.
- super_type_args.SetTypeAt(cloned_index, cloned_param);
- cloned_index++;
- }
- Type::Cast(super_type).set_arguments(super_type_args);
- ASSERT(!super_type.IsFinalized());
- }
-
- // Second, clone the type parameters of the mixin class.
- // We need to retain the parameter names of the mixin class
- // since the code that will be compiled in the context of the
- // mixin application class may refer to the type parameters
- // with that name. We also retain the type parameter bounds.
- if (num_mixin_type_params > 0) {
- const TypeArguments& mixin_params =
- TypeArguments::Handle(zone, mixin_class.type_parameters());
- const intptr_t offset =
- mixin_class.NumTypeArguments() - mixin_class.NumTypeParameters();
- const TypeArguments& mixin_type_args = TypeArguments::Handle(
- zone, TypeArguments::New(num_mixin_type_params));
- instantiator ^= TypeArguments::New(offset + num_mixin_type_params);
- bool has_uninstantiated_bounds = false;
- for (intptr_t i = 0; i < num_mixin_type_params; i++) {
- param ^= mixin_params.TypeAt(i);
- param_name = param.name();
- param_bound = param.bound(); // The bound will be adjusted below.
- if (!param_bound.IsInstantiated()) {
- has_uninstantiated_bounds = true;
- }
- cloned_param =
- TypeParameter::New(mixin_app_class, null_function,
- cloned_index, // Unfinalized index.
- param_name, param_bound, param.token_pos());
- cloned_type_params.SetTypeAt(cloned_index, cloned_param);
- mixin_type_args.SetTypeAt(i, cloned_param); // Unfinalized length.
- instantiator.SetTypeAt(offset + i, cloned_param); // Finalized length.
- cloned_index++;
- }
-
- // Third, replace the type parameters appearing in the bounds of the mixin
- // type parameters, if any, by the cloned type parameters. This can be
- // done by instantiating each bound using the instantiator built above.
- // If the mixin class extends a generic super class, its first finalized
- // type parameter has a non-zero index, therefore, the instantiator
- // requires shifting by the offset calculated above.
- // Unfinalized type parameters replace finalized type parameters, which
- // is not a problem since they will get finalized shortly as the mixin
- // application class gets finalized.
- if (has_uninstantiated_bounds) {
- for (intptr_t i = 0; i < num_mixin_type_params; i++) {
- param ^= mixin_type_args.TypeAt(i);
- param_bound = param.bound();
- if (!param_bound.IsInstantiated()) {
- // Make sure the bound is finalized before instantiating it.
- if (!param_bound.IsFinalized() && !param_bound.IsBeingFinalized()) {
- param_bound = FinalizeType(mixin_app_class, param_bound);
- param.set_bound(param_bound); // In case part of recursive type.
- }
- param_bound = param_bound.InstantiateFrom(
- instantiator, Object::null_type_arguments(), kNoneFree, NULL,
- Heap::kOld);
- // The instantiator contains only TypeParameter objects.
- ASSERT(!param_bound.IsInstantiated());
- param.set_bound(param_bound);
- }
- }
- }
-
- // Lastly, set the type arguments of the mixin type, which is also the
- // single interface type.
- ASSERT(!mixin_type.IsFinalized());
- mixin_type.set_arguments(mixin_type_args);
- if (share_type_params) {
- Type::Cast(super_type).set_arguments(mixin_type_args);
- ASSERT(!super_type.IsFinalized());
- }
- }
- mixin_app_class.set_type_parameters(cloned_type_params);
- }
- // If the mixin class is a mixin application alias class, we insert a new
- // synthesized mixin application class in the super chain of this mixin
- // application class. The new class will have the aliased mixin as actual
- // mixin.
- if (mixin_class.is_mixin_app_alias()) {
- ApplyMixinAppAlias(mixin_app_class, instantiator);
- }
-}
-
-/* Support for mixin alias.
-Consider the following example:
-
-class I<T> { }
-class J<T> { }
-class S<T extends num> { }
-class M<T extends Map> { }
-class A<U, V extends List> = Object with M<Map<U, V>> implements I<V>;
-class C<T, K extends T> = S<T> with A<T, List<K>> implements J<K>;
-
-Before the call to ApplyMixinAppAlias, the VM has already synthesized 2 mixin
-application classes Object&M and S&A:
-
-Object&M<T extends Map> extends Object implements M<T> {
- ... members of M applied here ...
-}
-A<U, V extends List> extends Object&M<Map<U, V>> implements I<V> { }
-
-S&A<T`, U, V extends List> extends S<T`> implements A<U, V> {
- ... members of A applied here, but A has no members ...
-}
-C<T, K extends T> extends S&A<T, T, List<K>> implements J<K> { }
-
-In theory, class A should be an alias of Object&M instead of extending it.
-In practice, the additional class provides a hook for implemented interfaces
-(e.g. I<V>) and for type argument substitution via the super type relation (e.g.
-type parameter T of Object&M is substituted with Map<U, V>, U and V being the
-type parameters of the alias A).
-
-Similarly, class C should be an alias of S&A instead of extending it.
-
-Now, A does not have any members to be mixed into S&A, because A is an alias.
-The members to be mixed in are actually those of M, and they should appear in a
-scope where the type parameter T is visible. The class S&A declares the type
-parameters of A, i.e. U and V, but not T.
-
-Therefore, the call to ApplyMixinAppAlias inserts another synthesized class S&A`
-as the superclass of S&A. The class S&A` declares a type argument T:
-
-Instead of
-S&A<T`, U, V extends List> extends S<T`> implements A<U, V> { }
-
-We now have:
-S&A`<T`, T extends Map> extends S<T`> implements M<T> {
- ... members of M applied here ...
-}
-S&A<T`, U, V extends List> extends S&A`<T`, Map<U, V>> implements A<U, V> { }
-
-The main implementation difficulty resides in the fact that the type parameters
-U and V in the super type S&A`<T`, Map<U, V>> of S&A must refer to the type
-parameters U and V of S&A. However, Map<U, V> is copied from the super type
-Object&M<Map<U, V>> of A and, therefore, U and V refer to A. An instantiation
-step with a properly crafted instantiator vector takes care of the required type
-parameter substitution.
-The instantiator vector must end with the type parameters U and V of S&A.
-The offset in the instantiator of the type parameter U of S&A must be at the
-finalized index of type parameter U of A.
-
-The same instantiator vector is used to adjust the type parameter bounds on U
-and V, if any. This step is done in CloneMixinAppTypeParameters above, and the
-already built instantiator is passed here.
-
-Also, a possible bound on type parameter T of M must be applied to type
-parameter T of S&A`. If the bound is uninstantiated, i.e. if it refers to T or
-other type parameters of M, an instantiation step is required to substitute
-these type parameters of M with type parameters of S&A`.
-The instantiator vector consists of the cloned type parameters of M shifted by
-an offset corresponding to the finalized index of the first type parameter of M.
-This is done in the recursive call to CloneMixinAppTypeParameters and does not
-require specific code in ApplyMixinAppAlias.
-*/
-void ClassFinalizer::ApplyMixinAppAlias(const Class& mixin_app_class,
- const TypeArguments& instantiator) {
- // If this mixin alias is aliasing another mixin alias, another class
- // will be inserted via recursion. No need to check here.
- // The mixin type may or may not be finalized yet.
- Thread* thread = Thread::Current();
- Zone* zone = thread->zone();
- AbstractType& super_type =
- AbstractType::Handle(zone, mixin_app_class.super_type());
- const Type& mixin_type = Type::Handle(zone, mixin_app_class.mixin());
- const Class& mixin_class = Class::Handle(zone, mixin_type.type_class());
- ASSERT(mixin_class.is_mixin_app_alias());
- const Class& aliased_mixin_app_class =
- Class::Handle(zone, mixin_class.SuperClass());
- // Note that the super class of aliased_mixin_app_class can itself be a
- // mixin application class (this happens if the alias is mixing more than one
- // type). Instead of trying to recursively insert yet another class as the
- // super class of this inserted class, we apply the composition rules of the
- // spec and only mixin the members of aliased_mixin_app_class, not those of
- // its super class. In other words, we only mixin the last mixin of the alias.
- const Type& aliased_mixin_type =
- Type::Handle(zone, aliased_mixin_app_class.mixin());
- // The name of the inserted mixin application class is the name of mixin
- // class name with a backtick added.
- String& inserted_class_name = String::Handle(zone, mixin_app_class.Name());
- inserted_class_name =
- String::Concat(inserted_class_name, Symbols::Backtick());
- const Library& library = Library::Handle(zone, mixin_app_class.library());
- Class& inserted_class =
- Class::Handle(zone, library.LookupLocalClass(inserted_class_name));
- if (inserted_class.IsNull()) {
- inserted_class_name = Symbols::New(thread, inserted_class_name);
- const Script& script = Script::Handle(zone, mixin_app_class.script());
- inserted_class = Class::New(library, inserted_class_name, script,
- mixin_app_class.token_pos());
- inserted_class.set_is_synthesized_class();
- library.AddClass(inserted_class);
-
- if (FLAG_trace_class_finalization) {
- THR_Print("Creating mixin application alias %s\n",
- inserted_class.ToCString());
- }
-
- // The super type of the inserted class is identical to the super type of
- // this mixin application class, except that it must refer to the type
- // parameters of the inserted class rather than to those of the mixin
- // application class.
- // The type arguments of the super type will be set properly when calling
- // CloneMixinAppTypeParameters on the inserted class, as long as the super
- // type class is set properly.
- inserted_class.set_super_type(super_type); // Super class only is used.
-
- // The mixin type and interface type must also be set before calling
- // CloneMixinAppTypeParameters.
- // After FinalizeTypesInClass, if the mixin type and interface type are
- // generic, their type arguments will refer to the type parameters of
- // inserted_class.
- const Type& inserted_class_mixin_type = Type::Handle(
- zone, Type::New(Class::Handle(zone, aliased_mixin_type.type_class()),
- Object::null_type_arguments(),
- aliased_mixin_type.token_pos()));
- inserted_class.set_mixin(inserted_class_mixin_type);
- // Add the mixin type to the list of interfaces that the mixin application
- // class implements. This is necessary so that cycle check work at
- // compile time (type arguments are ignored by that check).
- const Array& interfaces = Array::Handle(Array::New(1));
- interfaces.SetAt(0, inserted_class_mixin_type);
- ASSERT(inserted_class.interfaces() == Object::empty_array().raw());
- inserted_class.set_interfaces(interfaces);
- // The type arguments of the interface, if any, will be set in
- // CloneMixinAppTypeParameters, which is called indirectly from
- // FinalizeTypesInClass below.
- }
-
- // Finalize the types and call CloneMixinAppTypeParameters.
- FinalizeTypesInClass(inserted_class);
-
- // The super type of this mixin application class must point to the
- // inserted class. The super type arguments are the concatenation of the
- // old super type arguments (propagating type arguments to the super class)
- // with new type arguments providing type arguments to the mixin.
- // The appended type arguments are those of the super type of the mixin
- // application alias that are forwarding to the aliased mixin type, except
- // that they must refer to the type parameters of the mixin application
- // class rather than to those of the mixin application alias class.
- // This type parameter substitution is performed by an instantiation step.
- // It is important that the type parameters of the mixin application class
- // are not finalized yet, because new type parameters may have been added
- // to the super class.
- const Class& super_class = Class::Handle(zone, super_type.type_class());
- ASSERT(mixin_app_class.SuperClass() == super_class.raw()); // Will change.
- const intptr_t num_super_type_params = super_class.NumTypeParameters();
- AbstractType& type = AbstractType::Handle(zone);
- // The instantiator is mapping finalized type parameters of mixin_class to
- // unfinalized type parameters of mixin_app_class. Therefore, the type
- // arguments of mixin_class_super_type must be finalized, since they get
- // instantiated by this instantiator. Finalizing the types in mixin_class
- // will finalize mixin_class_super_type.
- // The aliased_mixin_type does not need to be finalized, but only resolved.
- ASSERT(aliased_mixin_type.IsResolved());
- const Class& aliased_mixin_type_class =
- Class::Handle(zone, aliased_mixin_type.type_class());
- FinalizeTypesInClass(mixin_class);
- const intptr_t num_aliased_mixin_type_params =
- aliased_mixin_type_class.NumTypeParameters();
- ASSERT(inserted_class.NumTypeParameters() ==
- (num_super_type_params + num_aliased_mixin_type_params));
- const AbstractType& mixin_class_super_type =
- AbstractType::Handle(zone, mixin_class.super_type());
- ASSERT(mixin_class_super_type.IsFinalized());
- // The aliased_mixin_type may be raw.
- const TypeArguments& mixin_class_super_type_args =
- TypeArguments::Handle(zone, mixin_class_super_type.arguments());
- TypeArguments& new_mixin_type_args = TypeArguments::Handle(zone);
- if ((num_aliased_mixin_type_params > 0) &&
- !mixin_class_super_type_args.IsNull()) {
- new_mixin_type_args = TypeArguments::New(num_aliased_mixin_type_params);
- const intptr_t offset =
- mixin_class_super_type_args.Length() - num_aliased_mixin_type_params;
- for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
- type = mixin_class_super_type_args.TypeAt(offset + i);
- if (!type.IsInstantiated()) {
- type = type.InstantiateFrom(instantiator, Object::null_type_arguments(),
- kNoneFree, NULL, Heap::kOld);
- }
- new_mixin_type_args.SetTypeAt(i, type);
- }
- }
- TypeArguments& new_super_type_args = TypeArguments::Handle(zone);
- if ((num_super_type_params + num_aliased_mixin_type_params) > 0) {
- new_super_type_args = TypeArguments::New(num_super_type_params +
- num_aliased_mixin_type_params);
- const TypeArguments& type_params =
- TypeArguments::Handle(zone, mixin_app_class.type_parameters());
- for (intptr_t i = 0; i < num_super_type_params; i++) {
- type = type_params.TypeAt(i);
- new_super_type_args.SetTypeAt(i, type);
- }
- for (intptr_t i = 0; i < num_aliased_mixin_type_params; i++) {
- if (new_mixin_type_args.IsNull()) {
- type = Type::DynamicType();
- } else {
- type = new_mixin_type_args.TypeAt(i);
- }
- new_super_type_args.SetTypeAt(num_super_type_params + i, type);
- }
- }
- super_type = Type::New(inserted_class, new_super_type_args,
- mixin_app_class.token_pos());
- mixin_app_class.set_super_type(super_type);
-
- // Mark this mixin application class as being an alias.
- mixin_app_class.set_is_mixin_app_alias();
- ASSERT(!mixin_app_class.is_type_finalized());
- ASSERT(!mixin_app_class.is_mixin_type_applied());
- if (FLAG_trace_class_finalization) {
- THR_Print(
- "Inserting class '%s' %s\n"
- " as super type '%s' with %" Pd
- " type args: %s\n"
- " of mixin application alias '%s' %s\n",
- String::Handle(inserted_class.Name()).ToCString(),
- TypeArguments::Handle(inserted_class.type_parameters()).ToCString(),
- String::Handle(zone, super_type.Name()).ToCString(),
- num_super_type_params + num_aliased_mixin_type_params,
- super_type.ToCString(),
- String::Handle(mixin_app_class.Name()).ToCString(),
- TypeArguments::Handle(mixin_app_class.type_parameters()).ToCString());
- }
-}
-
-void ClassFinalizer::ApplyMixinType(const Class& mixin_app_class,
- PendingTypes* pending_types) {
- if (mixin_app_class.is_mixin_type_applied()) {
- return;
- }
- Type& mixin_type = Type::Handle(mixin_app_class.mixin());
- ASSERT(!mixin_type.IsNull());
- ASSERT(mixin_type.HasTypeClass());
- const Class& mixin_class = Class::Handle(mixin_type.type_class());
-
- if (FLAG_trace_class_finalization) {
- THR_Print("Applying mixin type '%s' to %s at pos %s\n",
- String::Handle(mixin_type.Name()).ToCString(),
- mixin_app_class.ToCString(),
- mixin_app_class.token_pos().ToCString());
- }
-
- // Check for illegal self references.
- GrowableArray<intptr_t> visited_mixins;
- if (!IsMixinCycleFree(mixin_class, &visited_mixins)) {
- const String& class_name = String::Handle(mixin_class.Name());
- ReportError(mixin_class, mixin_class.token_pos(),
- "mixin class '%s' illegally refers to itself",
- class_name.ToCString());
- }
-
- // Copy type parameters to mixin application class.
- CloneMixinAppTypeParameters(mixin_app_class);
-
- // Verify that no restricted class is used as a mixin by checking the
- // interfaces of the mixin application class, which implements its mixin.
- GrowableArray<intptr_t> visited_interfaces;
- ResolveSuperTypeAndInterfaces(mixin_app_class, &visited_interfaces);
-
- if (FLAG_trace_class_finalization) {
- THR_Print(
- "Done applying mixin type '%s' to class '%s' %s extending '%s'\n",
- String::Handle(mixin_type.Name()).ToCString(),
- String::Handle(mixin_app_class.Name()).ToCString(),
- TypeArguments::Handle(mixin_app_class.type_parameters()).ToCString(),
- AbstractType::Handle(mixin_app_class.super_type()).ToCString());
- }
- // Mark the application class as having been applied its mixin type in order
- // to avoid cycles while finalizing its mixin type.
- mixin_app_class.set_is_mixin_type_applied();
- // Finalize the mixin type, which may have been changed in case
- // mixin_app_class is an alias.
- mixin_type = mixin_app_class.mixin();
- ASSERT(!mixin_type.IsBeingFinalized());
- mixin_type ^=
- FinalizeType(mixin_app_class, mixin_type, kFinalize, pending_types);
- mixin_app_class.set_mixin(mixin_type);
-}
-
-void ClassFinalizer::CreateForwardingConstructors(
- const Class& mixin_app,
- const Class& mixin_cls,
- const GrowableObjectArray& cloned_funcs) {
- Thread* T = Thread::Current();
- Zone* Z = T->zone();
- const String& mixin_name = String::Handle(Z, mixin_app.Name());
- const Class& super_class = Class::Handle(Z, mixin_app.SuperClass());
- const String& super_name = String::Handle(Z, super_class.Name());
- const Array& functions = Array::Handle(Z, super_class.functions());
- const intptr_t num_functions = functions.Length();
- Function& func = Function::Handle(Z);
- for (intptr_t i = 0; i < num_functions; i++) {
- func ^= functions.At(i);
- if (func.IsGenerativeConstructor()) {
- // Build constructor name from mixin application class name
- // and name of cloned super class constructor.
- const String& ctor_name = String::Handle(Z, func.name());
- String& clone_name =
- String::Handle(Z, String::SubString(ctor_name, super_name.Length()));
- clone_name = Symbols::FromConcat(T, mixin_name, clone_name);
-
- if (FLAG_trace_class_finalization) {
- THR_Print("Cloning constructor '%s' as '%s'\n", ctor_name.ToCString(),
- clone_name.ToCString());
- }
-
- // The owner of the forwarding constructor is the mixin application
- // class. The source is the mixin class. The source may be needed
- // to parse field initializer expressions in the mixin class.
- const PatchClass& owner =
- PatchClass::Handle(Z, PatchClass::New(mixin_app, mixin_cls));
-
- const Function& clone = Function::Handle(
- Z, Function::New(clone_name, func.kind(), func.is_static(),
- false, // Not const.
- false, // Not abstract.
- false, // Not external.
- false, // Not native.
- owner, mixin_cls.token_pos()));
- clone.set_num_fixed_parameters(func.num_fixed_parameters());
- clone.SetNumOptionalParameters(func.NumOptionalParameters(),
- func.HasOptionalPositionalParameters());
- clone.set_result_type(Object::dynamic_type());
- clone.set_is_debuggable(false);
-
- const intptr_t num_parameters = func.NumParameters();
- // The cloned ctor shares the parameter names array with the
- // original.
- const Array& parameter_names = Array::Handle(Z, func.parameter_names());
- ASSERT(parameter_names.Length() == num_parameters);
- clone.set_parameter_names(parameter_names);
- // The parameter types of the cloned constructor are 'dynamic'.
- clone.set_parameter_types(Array::Handle(Z, Array::New(num_parameters)));
- for (intptr_t n = 0; n < num_parameters; n++) {
- clone.SetParameterTypeAt(n, Object::dynamic_type());
- }
- cloned_funcs.Add(clone);
- }
- }
-}
-
-void ClassFinalizer::ApplyMixinMembers(const Class& cls) {
- Zone* zone = Thread::Current()->zone();
- const Type& mixin_type = Type::Handle(zone, cls.mixin());
- ASSERT(!mixin_type.IsNull());
- ASSERT(mixin_type.HasTypeClass());
- const Class& mixin_cls = Class::Handle(zone, mixin_type.type_class());
- FinalizeClass(mixin_cls);
- // If the mixin is a mixin application alias class, there are no members to
- // apply here. A new synthesized class representing the aliased mixin
- // application class was inserted in the super chain of this mixin application
- // class. Members of the actual mixin class will be applied when visiting
- // the mixin application class referring to the actual mixin.
- ASSERT(!mixin_cls.is_mixin_app_alias() ||
- Class::Handle(zone, cls.SuperClass()).IsMixinApplication());
- // A default constructor will be created for the mixin app alias class.
-
- if (FLAG_trace_class_finalization) {
- THR_Print("Applying mixin members of %s to %s at pos %s\n",
- mixin_cls.ToCString(), cls.ToCString(),
- cls.token_pos().ToCString());
- }
-
- const GrowableObjectArray& cloned_funcs =
- GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
-
- Array& functions = Array::Handle(zone);
- Function& func = Function::Handle(zone);
-
- // The parser creates the mixin application class with no functions.
- // But the Kernel frontend will generate mixin classes with only
- // constructors inside them, which forward to the base class constructors.
- //
- // => We generate the constructors if they are not already there.
- functions = cls.functions();
- if (functions.Length() == 0) {
- CreateForwardingConstructors(cls, mixin_cls, cloned_funcs);
- } else {
- for (intptr_t i = 0; i < functions.Length(); i++) {
- func ^= functions.At(i);
- ASSERT(func.kernel_offset() > 0);
- cloned_funcs.Add(func);
- }
- }
-
- // Now clone the functions from the mixin class.
- const Library& from_library = Library::Handle(zone, mixin_cls.library());
- const Library& to_library = Library::Handle(zone, cls.library());
- Function& from_func = Function::Handle(zone);
-
- functions = mixin_cls.functions();
- const intptr_t num_functions = functions.Length();
- for (intptr_t i = 0; i < num_functions; i++) {
- from_func ^= functions.At(i);
- if (from_func.IsGenerativeConstructor()) {
- // A mixin class must not have explicit constructors.
- if (!from_func.IsImplicitConstructor()) {
- const Script& script = Script::Handle(cls.script());
- const Error& error = Error::Handle(LanguageError::NewFormatted(
- Error::Handle(), script, from_func.token_pos(), Report::AtLocation,
- Report::kError, Heap::kNew,
- "constructor '%s' is illegal in mixin class %s",
- String::Handle(from_func.UserVisibleName()).ToCString(),
- String::Handle(zone, mixin_cls.Name()).ToCString()));
-
- ReportErrors(error, cls, cls.token_pos(),
- "mixin class '%s' must not have constructors",
- String::Handle(zone, mixin_cls.Name()).ToCString());
- }
- continue; // Skip the implicit constructor.
- }
- if (!from_func.is_static() && !from_func.IsMethodExtractor() &&
- !from_func.IsNoSuchMethodDispatcher() &&
- !from_func.IsInvokeFieldDispatcher()) {
- func = from_func.Clone(cls);
- to_library.CloneMetadataFrom(from_library, from_func, func);
- cloned_funcs.Add(func);
- }
- }
- functions = Array::MakeFixedLength(cloned_funcs);
- cls.SetFunctions(functions);
-
- // Now clone the fields from the mixin class. There should be no
- // existing fields in the mixin application class.
- ASSERT(Array::Handle(cls.fields()).Length() == 0);
- const Array& fields = Array::Handle(zone, mixin_cls.fields());
- const intptr_t num_fields = fields.Length();
- Field& field = Field::Handle(zone);
- GrowableArray<const Field*> cloned_fields(num_fields);
- for (intptr_t i = 0; i < num_fields; i++) {
- field ^= fields.At(i);
- // Static fields are shared between the mixin class and the mixin
- // application class.
- if (!field.is_static()) {
- const Field& cloned = Field::ZoneHandle(zone, field.Clone(cls));
- cloned_fields.Add(&cloned);
- }
- }
- cls.AddFields(cloned_fields);
-
- if (FLAG_trace_class_finalization) {
- THR_Print("Done applying mixin members of %s to %s\n",
- mixin_cls.ToCString(), cls.ToCString());
- }
-}
-
void ClassFinalizer::FinalizeTypesInClass(const Class& cls) {
Thread* thread = Thread::Current();
HANDLESCOPE(thread);
@@ -1948,11 +1001,6 @@
FinalizeTypeParameters(cls); // May change super type while applying mixin.
super_class = cls.SuperClass(); // Get again possibly changed super class.
ASSERT(super_class.IsNull() || super_class.is_type_finalized());
- // Only resolving rather than finalizing the upper bounds here would result in
- // instantiated type parameters of the super type to temporarily have
- // unfinalized bounds. It is more efficient to finalize them early.
- // Finalize bounds even if running in production mode, so that a snapshot
- // contains them.
FinalizeUpperBounds(cls);
// Finalize super type.
AbstractType& super_type = AbstractType::Handle(cls.super_type());
@@ -1960,12 +1008,6 @@
super_type = FinalizeType(cls, super_type);
cls.set_super_type(super_type);
}
- // Finalize mixin type.
- Type& mixin_type = Type::Handle(cls.mixin());
- if (!mixin_type.IsNull()) {
- mixin_type ^= FinalizeType(cls, mixin_type);
- cls.set_mixin(mixin_type);
- }
if (cls.IsTypedefClass()) {
Function& signature = Function::Handle(cls.signature_function());
Type& type = Type::Handle(signature.SignatureType());
@@ -1981,12 +1023,12 @@
}
cls.set_is_type_finalized();
- // Resolve and finalize the result and parameter types of the signature
+ // Finalize the result and parameter types of the signature
// function of this typedef class.
FinalizeSignature(cls, signature); // Does not modify signature type.
ASSERT(signature.SignatureType() == type.raw());
- // Resolve and finalize the signature type of this typedef.
+ // Finalize the signature type of this typedef.
type ^= FinalizeType(cls, type);
ASSERT(type.type_class() == cls.raw());
@@ -2036,8 +1078,6 @@
}
}
}
- // Mark as type finalized before resolving type parameter upper bounds
- // in order to break cycles.
cls.set_is_type_finalized();
// Add this class to the direct subclasses of the superclass, unless the
@@ -2077,7 +1117,7 @@
// This class should not contain any functions or user-defined fields yet,
// because it has not been compiled yet. There may however be metadata
// fields because type parameters are parsed before the class body. Since
- // 'ResolveAndFinalizeMemberTypes(cls)' has not been called yet, unfinalized
+ // 'FinalizeMemberTypes(cls)' has not been called yet, unfinalized
// member types could choke the snapshotter.
// Or
// if the class is being refinalized because a patch is being applied
@@ -2140,37 +1180,15 @@
if (!super.IsNull()) {
FinalizeClass(super);
}
- if (cls.IsMixinApplication()) {
- // Copy instance methods and fields from the mixin class.
- // This has to happen before the check whether the methods of
- // the class conflict with inherited methods.
- ApplyMixinMembers(cls);
- }
// Mark as parsed and finalized.
cls.Finalize();
- // Mixin app alias classes may still lack their forwarding constructor.
- if (cls.is_mixin_app_alias() &&
- (cls.functions() == Object::empty_array().raw())) {
- const GrowableObjectArray& cloned_funcs =
- GrowableObjectArray::Handle(GrowableObjectArray::New());
-
- const Class& mixin_app_class = Class::Handle(cls.SuperClass());
- const Type& mixin_type = Type::Handle(mixin_app_class.mixin());
- const Class& mixin_cls = Class::Handle(mixin_type.type_class());
-
- CreateForwardingConstructors(cls, mixin_cls, cloned_funcs);
- const Array& functions =
- Array::Handle(Array::MakeFixedLength(cloned_funcs));
- cls.SetFunctions(functions);
- }
// Every class should have at least a constructor, unless it is a top level
// class or a typedef class. The Kernel frontend does not create an implicit
// constructor for abstract classes.
// Moreover, Dart 2 precompiler (TFA) can tree shake all members if unused.
ASSERT(FLAG_precompiled_mode || cls.IsTopLevel() || cls.IsTypedefClass() ||
cls.is_abstract() || (Array::Handle(cls.functions()).Length() > 0));
- // Resolve and finalize all member types.
- ResolveAndFinalizeMemberTypes(cls);
+ FinalizeMemberTypes(cls);
// Run additional checks after all types are finalized.
if (cls.is_const()) {
CheckForLegalConstClass(cls);
@@ -2318,7 +1336,6 @@
const AbstractType& type,
GrowableArray<intptr_t>* visited) {
ASSERT(visited != NULL);
- ResolveType(cls, type);
bool checking_typedef = false;
if (type.IsType()) {
AbstractType& other_type = AbstractType::Handle();
@@ -2387,226 +1404,6 @@
return true;
}
-// Returns false if the mixin illegally refers to itself.
-bool ClassFinalizer::IsMixinCycleFree(const Class& cls,
- GrowableArray<intptr_t>* visited) {
- ASSERT(visited != NULL);
- const intptr_t cls_index = cls.id();
- for (intptr_t i = 0; i < visited->length(); i++) {
- if ((*visited)[i] == cls_index) {
- // We have already visited mixin 'cls'. We found a cycle.
- return false;
- }
- }
-
- // Visit the super chain of cls.
- visited->Add(cls.id());
- Class& super_class = Class::Handle(cls.raw());
- do {
- if (super_class.IsMixinApplication()) {
- const Type& mixin_type = Type::Handle(super_class.mixin());
- ASSERT(!mixin_type.IsNull());
- ASSERT(mixin_type.HasTypeClass());
- const Class& mixin_class = Class::Handle(mixin_type.type_class());
- if (!IsMixinCycleFree(mixin_class, visited)) {
- return false;
- }
- }
- super_class = super_class.SuperClass();
- } while (!super_class.IsNull());
- visited->RemoveLast();
- return true;
-}
-
-void ClassFinalizer::CollectTypeArguments(
- const Class& cls,
- const Type& type,
- const GrowableObjectArray& collected_args) {
- ASSERT(type.HasTypeClass());
- Class& type_class = Class::Handle(type.type_class());
- TypeArguments& type_args = TypeArguments::Handle(type.arguments());
- const intptr_t num_type_parameters = type_class.NumTypeParameters();
- const intptr_t num_type_arguments =
- type_args.IsNull() ? 0 : type_args.Length();
- AbstractType& arg = AbstractType::Handle();
- if (num_type_arguments > 0) {
- if (num_type_arguments == num_type_parameters) {
- for (intptr_t i = 0; i < num_type_arguments; i++) {
- arg = type_args.TypeAt(i);
- arg = arg.CloneUnfinalized();
- ASSERT(!arg.IsBeingFinalized());
- collected_args.Add(arg);
- }
- return;
- }
- // TODO(regis): Check if this is dead code.
- // Discard provided type arguments and treat type as raw.
- }
- // Fill arguments with type dynamic.
- for (intptr_t i = 0; i < num_type_parameters; i++) {
- arg = Type::DynamicType();
- collected_args.Add(arg);
- }
-}
-
-RawType* ClassFinalizer::ResolveMixinAppType(
- const Class& cls,
- const MixinAppType& mixin_app_type) {
- // Lookup or create mixin application classes in the library of cls
- // and resolve super type and mixin types.
- Thread* thread = Thread::Current();
- Zone* zone = thread->zone();
- const Library& library = Library::Handle(zone, cls.library());
- ASSERT(!library.IsNull());
- const Script& script = Script::Handle(zone, cls.script());
- ASSERT(!script.IsNull());
- const GrowableObjectArray& type_args =
- GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
- AbstractType& mixin_super_type =
- AbstractType::Handle(zone, mixin_app_type.super_type());
- ResolveType(cls, mixin_super_type);
- ASSERT(mixin_super_type.HasTypeClass()); // Even if malformed.
- if (mixin_super_type.IsDynamicType()) {
- ReportError(cls, cls.token_pos(), "class '%s' may not extend 'dynamic'",
- String::Handle(zone, cls.Name()).ToCString());
- }
- CollectTypeArguments(cls, Type::Cast(mixin_super_type), type_args);
- AbstractType& mixin_type = AbstractType::Handle(zone);
- Class& mixin_app_class = Class::Handle(zone);
- Class& mixin_super_type_class = Class::Handle(zone);
- Class& mixin_type_class = Class::Handle(zone);
- Library& mixin_super_type_library = Library::Handle(zone);
- Library& mixin_type_library = Library::Handle(zone);
- String& mixin_app_class_name = String::Handle(zone);
- String& mixin_type_class_name = String::Handle(zone);
- AbstractType& super_type_arg = AbstractType::Handle(zone);
- AbstractType& mixin_type_arg = AbstractType::Handle(zone);
- Type& generic_mixin_type = Type::Handle(zone);
- Array& interfaces = Array::Handle(zone);
- const intptr_t depth = mixin_app_type.Depth();
- for (intptr_t i = 0; i < depth; i++) {
- mixin_type = mixin_app_type.MixinTypeAt(i);
- ASSERT(!mixin_type.IsNull());
- ResolveType(cls, mixin_type);
- ASSERT(mixin_type.HasTypeClass()); // Even if malformed.
- ASSERT(mixin_type.IsType());
- if (mixin_type.IsDynamicType()) {
- ReportError(cls, cls.token_pos(), "class '%s' may not mixin 'dynamic'",
- String::Handle(zone, cls.Name()).ToCString());
- }
- const intptr_t num_super_type_args = type_args.Length();
- CollectTypeArguments(cls, Type::Cast(mixin_type), type_args);
-
- // If the mixin type has identical type arguments as the super type, they
- // can share the same type parameters of the mixin application class,
- // thereby allowing for further optimizations, such as instantiator vector
- // reuse or sharing of type arguments with the super class.
- bool share_type_params = (num_super_type_args > 0) &&
- (type_args.Length() == 2 * num_super_type_args);
- if (share_type_params) {
- for (intptr_t i = 0; i < num_super_type_args; i++) {
- super_type_arg ^= type_args.At(i);
- mixin_type_arg ^= type_args.At(num_super_type_args + i);
- if (!super_type_arg.Equals(mixin_type_arg)) {
- share_type_params = false;
- break;
- }
- }
- if (share_type_params) {
- // Cut the type argument vector in half.
- type_args.SetLength(num_super_type_args);
- }
- }
-
- // The name of the mixin application class is a combination of
- // the super class name and mixin class name, as well as their respective
- // library private keys if their library is different than the library of
- // the mixin application class.
- // Note that appending the library url would break naming conventions (e.g.
- // no period in the class name).
- mixin_app_class_name = mixin_super_type.ClassName();
- mixin_super_type_class = mixin_super_type.type_class();
- mixin_super_type_library = mixin_super_type_class.library();
- if (mixin_super_type_library.raw() != library.raw()) {
- mixin_app_class_name = String::Concat(
- mixin_app_class_name,
- String::Handle(zone, mixin_super_type_library.private_key()));
- }
- mixin_app_class_name =
- String::Concat(mixin_app_class_name, Symbols::Ampersand());
- // If the type parameters are shared between the super type and the mixin
- // type, use two ampersand symbols, so that the class has a different name
- // and is not reused in a context where this optimization is not possible.
- if (share_type_params) {
- mixin_app_class_name =
- String::Concat(mixin_app_class_name, Symbols::Ampersand());
- }
- mixin_type_class_name = mixin_type.ClassName();
- mixin_type_class = mixin_type.type_class();
- mixin_type_library = mixin_type_class.library();
- if (mixin_type_library.raw() != library.raw()) {
- mixin_type_class_name = String::Concat(
- mixin_type_class_name,
- String::Handle(zone, mixin_type_library.private_key()));
- }
- mixin_app_class_name =
- String::Concat(mixin_app_class_name, mixin_type_class_name);
- mixin_app_class = library.LookupLocalClass(mixin_app_class_name);
- if (mixin_app_class.IsNull()) {
- mixin_app_class_name = Symbols::New(thread, mixin_app_class_name);
- mixin_app_class = Class::New(library, mixin_app_class_name, script,
- mixin_type.token_pos());
- mixin_app_class.set_super_type(mixin_super_type);
- generic_mixin_type =
- Type::New(mixin_type_class, Object::null_type_arguments(),
- mixin_type.token_pos());
- mixin_app_class.set_mixin(generic_mixin_type);
- // Add the mixin type to the list of interfaces that the mixin application
- // class implements. This is necessary so that cycle check work at
- // compile time (type arguments are ignored by that check).
- interfaces = Array::New(1);
- interfaces.SetAt(0, generic_mixin_type);
- ASSERT(mixin_app_class.interfaces() == Object::empty_array().raw());
- mixin_app_class.set_interfaces(interfaces);
- mixin_app_class.set_is_synthesized_class();
- library.AddClass(mixin_app_class);
-
- // No need to add the new class to pending_classes, since it will be
- // processed via the super_type chain of a pending class.
-
- if (FLAG_trace_class_finalization) {
- THR_Print("Creating mixin application %s\n",
- mixin_app_class.ToCString());
- }
- }
- // This mixin application class becomes the type class of the super type of
- // the next mixin application class. It is however too early to provide the
- // correct super type arguments. We use the raw type for now.
- mixin_super_type = Type::New(mixin_app_class, Object::null_type_arguments(),
- mixin_type.token_pos());
- }
- TypeArguments& mixin_app_args = TypeArguments::Handle(zone);
- if (type_args.Length() > 0) {
- mixin_app_args = TypeArguments::New(type_args.Length());
- AbstractType& type_arg = AbstractType::Handle(zone);
- for (intptr_t i = 0; i < type_args.Length(); i++) {
- type_arg ^= type_args.At(i);
- mixin_app_args.SetTypeAt(i, type_arg);
- }
- }
- if (FLAG_trace_class_finalization) {
- THR_Print("ResolveMixinAppType: mixin appl type args: %s\n",
- mixin_app_args.ToCString());
- }
- // The mixin application class at depth k is a subclass of mixin application
- // class at depth k - 1. Build a new super type with the class at the highest
- // depth (the last one processed by the loop above) as the type class and the
- // collected type arguments from the super type and all mixin types.
- // This super type replaces the MixinAppType object in the class that extends
- // the mixin application.
- return Type::New(mixin_app_class, mixin_app_args, mixin_app_type.token_pos());
-}
-
// For a class used as an interface marks this class and all its superclasses
// implemented.
//
@@ -2627,19 +1424,17 @@
if (type.IsNull() || type.IsObjectType()) {
break;
}
- ASSERT(type.IsResolved());
cls = type.type_class();
}
}
// Recursively walks the graph of explicitly declared super type and
-// interfaces, resolving unresolved super types and interfaces.
-// Reports an error if there is an interface reference that cannot be
-// resolved, or if there is a cycle in the graph. We detect cycles by
+// interfaces.
+// Reports an error if there is a cycle in the graph. We detect cycles by
// remembering interfaces we've visited in each path through the
// graph. If we visit an interface a second time on a given path,
// we found a loop.
-void ClassFinalizer::ResolveSuperTypeAndInterfaces(
+void ClassFinalizer::CheckSuperTypeAndInterfaces(
const Class& cls,
GrowableArray<intptr_t>* visited) {
if (cls.is_cycle_free()) {
@@ -2647,7 +1442,7 @@
}
ASSERT(visited != NULL);
if (FLAG_trace_class_finalization) {
- THR_Print("Resolving super and interfaces: %s\n", cls.ToCString());
+ THR_Print("Checking super and interfaces: %s\n", cls.ToCString());
}
Zone* zone = Thread::Current()->zone();
const intptr_t cls_index = cls.id();
@@ -2660,8 +1455,7 @@
}
}
- // If the class/interface has no explicit super class/interfaces
- // and is not a mixin application, we are done.
+ // If the class/interface has no explicit super class/interfaces, we are done.
AbstractType& super_type = AbstractType::Handle(zone, cls.super_type());
Array& super_interfaces = Array::Handle(zone, cls.interfaces());
if ((super_type.IsNull() || super_type.IsObjectType()) &&
@@ -2670,29 +1464,18 @@
return;
}
- if (super_type.IsMixinAppType()) {
- // For the cycle check below to work, ResolveMixinAppType needs to set
- // the mixin interfaces in the super classes, even if only in raw form.
- // It is indeed too early to set the correct type arguments, which is not
- // a problem since they are ignored in the cycle check.
- const MixinAppType& mixin_app_type = MixinAppType::Cast(super_type);
- super_type = ResolveMixinAppType(cls, mixin_app_type);
- cls.set_super_type(super_type);
- }
-
// If cls belongs to core lib or is a synthetic class which could belong to
// the core library, the restrictions about allowed interfaces are lifted.
const bool exempt_from_hierarchy_restrictions =
cls.library() == Library::CoreLibrary() ||
String::Handle(cls.Name()).Equals(Symbols::DebugClassName());
- // Resolve and check the super type and interfaces of cls.
+ // Check the super type and interfaces of cls.
visited->Add(cls_index);
AbstractType& interface = AbstractType::Handle(zone);
Class& interface_class = Class::Handle(zone);
- // Resolve super type. Failures lead to a longjmp.
- ResolveType(cls, super_type);
+ // Check super type. Failures lead to a longjmp.
if (super_type.IsDynamicType()) {
ReportError(cls, cls.token_pos(), "class '%s' may not extend 'dynamic'",
String::Handle(zone, cls.Name()).ToCString());
@@ -2757,13 +1540,12 @@
interface_name.ToCString());
}
}
- // Now resolve the super interfaces of the super type.
- ResolveSuperTypeAndInterfaces(interface_class, visited);
+ // Now check the super interfaces of the super type.
+ CheckSuperTypeAndInterfaces(interface_class, visited);
- // Resolve interfaces. Failures lead to a longjmp.
+ // Check interfaces. Failures lead to a longjmp.
for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
interface ^= super_interfaces.At(i);
- ResolveType(cls, interface);
ASSERT(!interface.IsTypeParameter()); // Should be detected by parser.
if (interface.IsDynamicType()) {
ReportError(cls, cls.token_pos(),
@@ -2793,20 +1575,15 @@
interface.IsDynamicType()) {
const String& interface_name =
String::Handle(zone, interface_class.Name());
- if (cls.IsMixinApplication()) {
- ReportError(cls, cls.token_pos(), "illegal mixin of '%s'",
- interface_name.ToCString());
- } else {
- ReportError(cls, cls.token_pos(),
- "'%s' is not allowed to extend or implement '%s'",
- String::Handle(zone, cls.Name()).ToCString(),
- interface_name.ToCString());
- }
+ ReportError(cls, cls.token_pos(),
+ "'%s' is not allowed to extend or implement '%s'",
+ String::Handle(zone, cls.Name()).ToCString(),
+ interface_name.ToCString());
}
}
- // Now resolve the super interfaces.
- ResolveSuperTypeAndInterfaces(interface_class, visited);
+ // Now check the super interfaces.
+ CheckSuperTypeAndInterfaces(interface_class, visited);
MarkImplemented(zone, interface_class);
}
visited->RemoveLast();
diff --git a/runtime/vm/class_finalizer.h b/runtime/vm/class_finalizer.h
index cd51414..565e452 100644
--- a/runtime/vm/class_finalizer.h
+++ b/runtime/vm/class_finalizer.h
@@ -17,13 +17,10 @@
public:
typedef ZoneGrowableHandlePtrArray<const AbstractType> PendingTypes;
- // Modes for type resolution and finalization. The ordering is relevant.
+ // Modes for finalization. The ordering is relevant.
enum FinalizationKind {
- kIgnore, // Type is ignored and replaced by dynamic.
- kDoNotResolve, // Type resolution is postponed.
- kResolveTypeParameters, // Resolve type parameters only.
- kFinalize, // Resolve and finalize type and type arguments.
- kCanonicalize // Finalize, check bounds, and canonicalize.
+ kFinalize, // Finalize type and type arguments.
+ kCanonicalize // Finalize and canonicalize.
};
// Finalize given type while parsing class cls.
@@ -69,47 +66,15 @@
static void VerifyBootstrapClasses();
#endif // !defined(DART_PRECOMPILED_RUNTIME)
- // Resolve the class of the type, but not the type's type arguments.
- // May promote the type to function type by setting its signature field.
- static void ResolveTypeClass(const Class& cls, const Type& type);
-
- // Resolve the type and target of the redirecting factory.
- static void ResolveRedirectingFactory(const Class& cls,
- const Function& factory);
-
- // Apply the mixin type to the mixin application class.
- static void ApplyMixinType(const Class& mixin_app_class,
- PendingTypes* pending_types = NULL);
-
private:
static void AllocateEnumValues(const Class& enum_cls);
static bool IsSuperCycleFree(const Class& cls);
static bool IsTypedefCycleFree(const Class& cls,
const AbstractType& type,
GrowableArray<intptr_t>* visited);
- static bool IsMixinCycleFree(const Class& cls,
- GrowableArray<intptr_t>* visited);
static void CheckForLegalConstClass(const Class& cls);
- static void ResolveType(const Class& cls, const AbstractType& type);
- static void ResolveRedirectingFactoryTarget(
- const Class& cls,
- const Function& factory,
- const GrowableObjectArray& visited_factories);
- static void CloneMixinAppTypeParameters(const Class& mixin_app_class);
- static void ApplyMixinAppAlias(const Class& mixin_app_class,
- const TypeArguments& instantiator);
- static void ApplyMixinMembers(const Class& cls);
- static void CreateForwardingConstructors(
- const Class& mixin_app,
- const Class& mixin_cls,
- const GrowableObjectArray& cloned_funcs);
- static void CollectTypeArguments(const Class& cls,
- const Type& type,
- const GrowableObjectArray& collected_args);
- static RawType* ResolveMixinAppType(const Class& cls,
- const MixinAppType& mixin_app_type);
- static void ResolveSuperTypeAndInterfaces(const Class& cls,
- GrowableArray<intptr_t>* visited);
+ static void CheckSuperTypeAndInterfaces(const Class& cls,
+ GrowableArray<intptr_t>* visited);
static void FinalizeTypeParameters(const Class& cls,
PendingTypes* pending_types = NULL);
static intptr_t ExpandAndFinalizeTypeArguments(const Class& cls,
@@ -123,15 +88,11 @@
static void CheckRecursiveType(const Class& cls,
const AbstractType& type,
PendingTypes* pending_types);
- static void ResolveUpperBounds(const Class& cls);
static void FinalizeUpperBounds(
const Class& cls,
FinalizationKind finalization = kCanonicalize);
- static void ResolveSignature(const Class& cls, const Function& function);
- static void ResolveAndFinalizeMemberTypes(const Class& cls);
+ static void FinalizeMemberTypes(const Class& cls);
static void PrintClassInformation(const Class& cls);
- static void CollectInterfaces(const Class& cls,
- GrowableArray<const Class*>* collected);
static void ReportError(const Error& error);
static void ReportError(const Class& cls,
diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
index ae5d05d..08c3d82 100644
--- a/runtime/vm/compiler/aot/precompiler.cc
+++ b/runtime/vm/compiler/aot/precompiler.cc
@@ -575,9 +575,6 @@
type = cls.super_type();
AddType(type);
- type = cls.mixin();
- AddType(type);
-
if (cls.IsTypedefClass()) {
AddTypesOf(Function::Handle(Z, cls.signature_function()));
}
@@ -1421,24 +1418,18 @@
for (intptr_t i = 0; i < types.length(); i++) {
const AbstractType& type = types.At(i);
- if (!type.IsResolved()) {
- continue;
- }
-
if (type.InVMHeap()) {
// The only important types in the vm isolate are "dynamic"/"void", which
// will get their optimized top-type testing stub installed at creation.
continue;
}
- if (type.IsResolved()) {
- if (type_usage_info->IsUsedInTypeTest(type)) {
- instr = type_testing_stubs.OptimizedCodeForType(type);
- type.SetTypeTestingStub(instr);
+ if (type_usage_info->IsUsedInTypeTest(type)) {
+ instr = type_testing_stubs.OptimizedCodeForType(type);
+ type.SetTypeTestingStub(instr);
- // Ensure we retain the type.
- AddType(type);
- }
+ // Ensure we retain the type.
+ AddType(type);
}
}
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
index 98e05b6..58b6008 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
@@ -343,7 +343,7 @@
}
const Register kClassIdReg = R2;
__ LoadClassId(kClassIdReg, kInstanceReg);
- // See ClassFinalizer::ResolveSuperTypeAndInterfaces for list of restricted
+ // See ClassFinalizer::CheckSuperTypeAndInterfaces for list of restricted
// interfaces.
// Bool interface can be implemented only by core class Bool.
if (type.IsBoolType()) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
index f3b8d7c..e3d2594 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
@@ -332,7 +332,7 @@
}
const Register kClassIdReg = R2;
__ LoadClassId(kClassIdReg, kInstanceReg);
- // See ClassFinalizer::ResolveSuperTypeAndInterfaces for list of restricted
+ // See ClassFinalizer::CheckSuperTypeAndInterfaces for list of restricted
// interfaces.
// Bool interface can be implemented only by core class Bool.
if (type.IsBoolType()) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc b/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
index ef7aa39..1fa3e5d 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
@@ -348,7 +348,7 @@
}
const Register kClassIdReg = ECX;
__ LoadClassId(kClassIdReg, kInstanceReg);
- // See ClassFinalizer::ResolveSuperTypeAndInterfaces for list of restricted
+ // See ClassFinalizer::CheckSuperTypeAndInterfaces for list of restricted
// interfaces.
// Bool interface can be implemented only by core class Bool.
if (type.IsBoolType()) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
index 2aff5e4..4a3574e 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
@@ -347,7 +347,7 @@
}
const Register kClassIdReg = R10;
__ LoadClassId(kClassIdReg, kInstanceReg);
- // See ClassFinalizer::ResolveSuperTypeAndInterfaces for list of restricted
+ // See ClassFinalizer::CheckSuperTypeAndInterfaces for list of restricted
// interfaces.
// Bool interface can be implemented only by core class Bool.
if (type.IsBoolType()) {
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
index e26c526..e9435cf 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
@@ -839,14 +839,7 @@
AbstractType& type = AbstractType::ZoneHandle(Z);
type ^= Type::New(owner, TypeArguments::Handle(Z), owner.token_pos(),
Heap::kOld);
- // If the current class is the result of a mixin application, we must
- // use the class scope of the class from which the function originates.
- if (owner.IsMixinApplication()) {
- ClassFinalizer::FinalizeType(
- Class::Handle(Z, parsed_function()->function().origin()), type);
- } else {
- type ^= ClassFinalizer::FinalizeType(owner, type);
- }
+ type ^= ClassFinalizer::FinalizeType(owner, type);
body += Constant(type);
} else {
body += LoadLocal(parsed_function()->current_context_var());
diff --git a/runtime/vm/compiler/frontend/kernel_fingerprints.cc b/runtime/vm/compiler/frontend/kernel_fingerprints.cc
index 7306848..ca2969c 100644
--- a/runtime/vm/compiler/frontend/kernel_fingerprints.cc
+++ b/runtime/vm/compiler/frontend/kernel_fingerprints.cc
@@ -777,12 +777,6 @@
hash = KernelFingerprintHelper::CalculateHash(hash, name.Hash());
}
- type ^= klass.mixin();
- if (!type.IsNull()) {
- name ^= type.Name();
- hash = KernelFingerprintHelper::CalculateHash(hash, name.Hash());
- }
-
Field& field = Field::Handle(zone);
// Calculate fingerprint for the class fields.
for (intptr_t i = 0; i < fields.Length(); ++i) {
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.cc b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
index 646f457..319ef4a 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.cc
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
@@ -568,13 +568,9 @@
Function& function = Function::ZoneHandle(
Z, klass.LookupFunctionAllowPrivate(procedure_name));
ASSERT(!function.IsNull());
-
- // TODO(27590): We can probably get rid of this after no longer using
- // core libraries from the source.
- if (function.IsRedirectingFactory()) {
- ClassFinalizer::ResolveRedirectingFactory(klass, function);
- function = function.RedirectionTarget();
- }
+ // Redirecting factory must be resolved.
+ ASSERT(!function.IsRedirectingFactory() ||
+ function.RedirectionTarget() != Function::null());
return function.raw();
}
}
diff --git a/runtime/vm/compiler/jit/compiler.cc b/runtime/vm/compiler/jit/compiler.cc
index b730884..19787c5 100644
--- a/runtime/vm/compiler/jit/compiler.cc
+++ b/runtime/vm/compiler/jit/compiler.cc
@@ -1292,11 +1292,6 @@
ASSERT(!func.IsNull());
if (!func.HasCode() &&
!func.is_abstract() && !func.IsRedirectingFactory()) {
- if ((cls.is_mixin_app_alias() || cls.IsMixinApplication()) &&
- func.HasOptionalParameters()) {
- // Skipping optional parameters in mixin application.
- continue;
- }
result = CompileFunction(thread, func);
if (result.IsError()) {
return Error::Cast(result).raw();
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index b873689..d880055 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -3801,7 +3801,6 @@
Instance& new_object = Instance::Handle(Z);
if (constructor.IsRedirectingFactory()) {
- ClassFinalizer::ResolveRedirectingFactory(cls, constructor);
Type& redirect_type = Type::Handle(constructor.RedirectionType());
constructor = constructor.RedirectionTarget();
ASSERT(!constructor.IsNull());
diff --git a/runtime/vm/isolate_reload.cc b/runtime/vm/isolate_reload.cc
index 3a3e6ab..4314d5c 100644
--- a/runtime/vm/isolate_reload.cc
+++ b/runtime/vm/isolate_reload.cc
@@ -1324,13 +1324,6 @@
return;
}
- // Don't report synthetic classes like the superclass of
- // `class MA extends S with M {}` or `class MA = S with M'. The relevant
- // changes with be reported as changes in M.
- if (new_cls.IsMixinApplication() || new_cls.is_mixin_app_alias()) {
- return;
- }
-
// Don't report `typedef bool Predicate(Object o)` as unused. There is nothing
// to execute.
if (new_cls.IsTypedefClass()) {
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index b85023b..676ca4e 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -1360,8 +1360,6 @@
const Class& type_ref_cls = Class::Handle(zone, Class::New<TypeRef>());
const Class& type_parameter_cls =
Class::Handle(zone, Class::New<TypeParameter>());
- const Class& mixin_app_type_cls =
- Class::Handle(zone, Class::New<MixinAppType>());
const Class& library_prefix_cls =
Class::Handle(zone, Class::New<LibraryPrefix>());
@@ -1521,10 +1519,6 @@
core_lib);
pending_classes.Add(type_parameter_cls);
- RegisterPrivateClass(mixin_app_type_cls, Symbols::_MixinAppType(),
- core_lib);
- pending_classes.Add(mixin_app_type_cls);
-
cls = Class::New<Integer>();
object_store->set_integer_implementation_class(cls);
RegisterPrivateClass(cls, Symbols::_IntegerImplementation(), core_lib);
@@ -1860,7 +1854,6 @@
cls = Class::New<Type>();
cls = Class::New<TypeRef>();
cls = Class::New<TypeParameter>();
- cls = Class::New<MixinAppType>();
cls = Class::New<Array>();
object_store->set_array_class(cls);
@@ -2509,9 +2502,6 @@
}
intptr_t Class::NumTypeParameters(Thread* thread) const {
- if (IsMixinApplication() && !is_mixin_type_applied()) {
- ClassFinalizer::ApplyMixinType(*this);
- }
if (type_parameters() == TypeArguments::null()) {
const intptr_t cid = id();
if ((cid == kArrayCid) || (cid == kImmutableArrayCid) ||
@@ -2540,7 +2530,6 @@
set_num_own_type_arguments(num_type_params);
return num_type_params;
}
- ASSERT(!IsMixinApplication() || is_mixin_type_applied());
const AbstractType& sup_type = AbstractType::Handle(zone, super_type());
const TypeArguments& sup_type_args =
TypeArguments::Handle(zone, sup_type.arguments());
@@ -2599,7 +2588,6 @@
}
// To work properly, this call requires the super class of this class to be
// resolved, which is checked by the type_class() call on the super type.
- // Note that calling type_class() on a MixinAppType fails.
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
Isolate* isolate = thread->isolate();
@@ -2608,8 +2596,6 @@
cls = raw();
intptr_t num_type_args = 0;
do {
- // Calling NumOwnTypeArguments() on a mixin application class will setup the
- // type parameters if not already done.
num_type_args += cls.NumOwnTypeArguments();
// Super type of Object class is null.
if ((cls.super_type() == AbstractType::null()) ||
@@ -2620,7 +2606,6 @@
// A TypeRef or function type can appear as type argument of
// sup_type, but not as sup_type itself.
ASSERT(sup_type.IsType());
- ClassFinalizer::ResolveTypeClass(cls, Type::Cast(sup_type));
cls = sup_type.type_class();
ASSERT(!cls.IsTypedefClass());
} while (true);
@@ -2649,8 +2634,7 @@
}
void Class::set_super_type(const AbstractType& value) const {
- ASSERT(value.IsNull() || (value.IsType() && !value.IsDynamicType()) ||
- value.IsMixinAppType());
+ ASSERT(value.IsNull() || (value.IsType() && !value.IsDynamicType()));
StorePointer(&raw_ptr()->super_type_, value.raw());
}
@@ -4011,7 +3995,7 @@
return TokenPosition::kNoSource;
#else
// Return the begin token for synthetic classes.
- if (is_synthesized_class() || IsMixinApplication() || IsTopLevel()) {
+ if (is_synthesized_class() || IsTopLevel()) {
return token_pos();
}
@@ -4099,14 +4083,6 @@
set_state_bits(ConstBit::update(true, raw_ptr()->state_bits_));
}
-void Class::set_is_mixin_app_alias() const {
- set_state_bits(MixinAppAliasBit::update(true, raw_ptr()->state_bits_));
-}
-
-void Class::set_is_mixin_type_applied() const {
- set_state_bits(MixinTypeAppliedBit::update(true, raw_ptr()->state_bits_));
-}
-
void Class::set_is_transformed_mixin_application() const {
set_state_bits(
TransformedMixinApplicationBit::update(true, raw_ptr()->state_bits_));
@@ -4164,15 +4140,6 @@
StorePointer(&raw_ptr()->interfaces_, value.raw());
}
-void Class::set_mixin(const Type& value) const {
- ASSERT(!value.IsNull());
- StorePointer(&raw_ptr()->mixin_, value.raw());
-}
-
-bool Class::IsMixinApplication() const {
- return mixin() != Type::null();
-}
-
RawClass* Class::GetPatchClass() const {
const Library& lib = Library::Handle(library());
return lib.GetPatchClass(String::Handle(Name()));
@@ -5144,18 +5111,6 @@
return false;
}
-void TypeArguments::SetScopeFunction(const Function& function) const {
- if (IsNull()) return;
- const intptr_t num_types = Length();
- AbstractType& type = AbstractType::Handle();
- for (intptr_t i = 0; i < num_types; i++) {
- type = TypeAt(i);
- if (!type.IsNull()) {
- type.SetScopeFunction(function);
- }
- }
-}
-
bool TypeArguments::IsDynamicTypes(bool raw_instantiated,
intptr_t from_index,
intptr_t len) const {
@@ -5258,21 +5213,6 @@
StorePointer(TypeAddr(index), value.raw());
}
-bool TypeArguments::IsResolved() const {
- if (IsCanonical()) {
- return true;
- }
- AbstractType& type = AbstractType::Handle();
- const intptr_t num_types = Length();
- for (intptr_t i = 0; i < num_types; i++) {
- type = TypeAt(i);
- if (!type.IsResolved()) {
- return false;
- }
- }
- return true;
-}
-
bool TypeArguments::IsSubvectorInstantiated(intptr_t from_index,
intptr_t len,
Genericity genericity,
@@ -5317,7 +5257,6 @@
// substituted by the instantiator's type argument vector without checking
// the upper bound.
const AbstractType& bound = AbstractType::Handle(type_param.bound());
- ASSERT(bound.IsResolved());
if (!bound.IsObjectType() && !bound.IsDynamicType()) {
return false;
}
@@ -5565,44 +5504,6 @@
StoreSmi(&raw_ptr()->length_, Smi::New(value));
}
-RawTypeArguments* TypeArguments::CloneUnfinalized() const {
- if (IsNull() || IsFinalized()) {
- return raw();
- }
- ASSERT(IsResolved());
- AbstractType& type = AbstractType::Handle();
- const intptr_t num_types = Length();
- const TypeArguments& clone =
- TypeArguments::Handle(TypeArguments::New(num_types));
- for (intptr_t i = 0; i < num_types; i++) {
- type = TypeAt(i);
- type = type.CloneUnfinalized();
- clone.SetTypeAt(i, type);
- }
- ASSERT(clone.IsResolved());
- return clone.raw();
-}
-
-RawTypeArguments* TypeArguments::CloneUninstantiated(const Class& new_owner,
- TrailPtr trail) const {
- ASSERT(!IsNull());
- ASSERT(IsFinalized());
- ASSERT(!IsInstantiated());
- AbstractType& type = AbstractType::Handle();
- const intptr_t num_types = Length();
- const TypeArguments& clone =
- TypeArguments::Handle(TypeArguments::New(num_types));
- for (intptr_t i = 0; i < num_types; i++) {
- type = TypeAt(i);
- if (!type.IsInstantiated()) {
- type = type.CloneUninstantiated(new_owner, trail);
- }
- clone.SetTypeAt(i, type);
- }
- ASSERT(clone.IsFinalized());
- return clone.raw();
-}
-
RawTypeArguments* TypeArguments::Canonicalize(TrailPtr trail) const {
if (IsNull() || IsCanonical()) {
ASSERT(IsOld());
@@ -7366,57 +7267,6 @@
return result.raw();
}
-RawFunction* Function::Clone(const Class& new_owner) const {
- ASSERT(!IsGenerativeConstructor());
- Thread* thread = Thread::Current();
- Zone* zone = thread->zone();
- Function& clone = Function::Handle(zone);
- clone ^= Object::Clone(*this, Heap::kOld);
- const Class& origin = Class::Handle(zone, this->origin());
- const PatchClass& clone_owner =
- PatchClass::Handle(zone, PatchClass::New(new_owner, origin));
- clone.set_owner(clone_owner);
- clone.ClearICDataArray();
- clone.ClearCode();
- clone.set_data(Object::null_object());
- clone.set_usage_counter(0);
- clone.set_deoptimization_counter(0);
- clone.set_optimized_instruction_count(0);
- clone.set_inlining_depth(0);
- clone.set_optimized_call_site_count(0);
-
- if (new_owner.NumTypeParameters() > 0) {
- // Adjust uninstantiated types to refer to type parameters of the new owner.
- const TypeArguments& type_params =
- TypeArguments::Handle(zone, type_parameters());
- if (!type_params.IsNull()) {
- const intptr_t num_type_params = type_params.Length();
- const TypeArguments& type_params_clone =
- TypeArguments::Handle(zone, TypeArguments::New(num_type_params));
- TypeParameter& type_param = TypeParameter::Handle(zone);
- for (intptr_t i = 0; i < num_type_params; i++) {
- type_param ^= type_params.TypeAt(i);
- type_param ^= type_param.CloneUninstantiated(new_owner);
- type_params_clone.SetTypeAt(i, type_param);
- }
- clone.set_type_parameters(type_params_clone);
- }
- AbstractType& type = AbstractType::Handle(zone, clone.result_type());
- type ^= type.CloneUninstantiated(new_owner);
- clone.set_result_type(type);
- const intptr_t num_params = clone.NumParameters();
- Array& array = Array::Handle(zone, clone.parameter_types());
- array ^= Object::Clone(array, Heap::kOld);
- clone.set_parameter_types(array);
- for (intptr_t i = 0; i < num_params; i++) {
- type = clone.ParameterTypeAt(i);
- type ^= type.CloneUninstantiated(new_owner);
- clone.SetParameterTypeAt(i, type);
- }
- }
- return clone.raw();
-}
-
RawFunction* Function::NewClosureFunctionWithKind(RawFunction::Kind kind,
const String& name,
const Function& parent,
@@ -8607,25 +8457,6 @@
return result.raw();
}
-RawField* Field::Clone(const Class& new_owner) const {
- Field& clone = Field::Handle();
- clone ^= Object::Clone(*this, Heap::kOld);
- const Class& owner = Class::Handle(this->Owner());
- const PatchClass& clone_owner =
- PatchClass::Handle(PatchClass::New(new_owner, owner));
- clone.set_owner(clone_owner);
- if (!clone.is_static()) {
- clone.SetOffset(0);
- }
- if (new_owner.NumTypeParameters() > 0) {
- // Adjust the field type to refer to type parameters of the new owner.
- AbstractType& type = AbstractType::Handle(clone.type());
- type ^= type.CloneUninstantiated(new_owner);
- clone.SetFieldType(type);
- }
- return clone.raw();
-}
-
RawField* Field::Clone(const Field& original) const {
if (original.IsNull()) {
return Field::null();
@@ -16488,17 +16319,6 @@
}
}
-bool AbstractType::IsResolved() const {
- // AbstractType is an abstract class.
- UNREACHABLE();
- return false;
-}
-
-void AbstractType::SetIsResolved() const {
- // AbstractType is an abstract class.
- UNREACHABLE();
-}
-
classid_t AbstractType::type_class_id() const {
// AbstractType is an abstract class.
UNREACHABLE();
@@ -16570,11 +16390,6 @@
return false;
}
-void AbstractType::SetScopeFunction(const Function& function) const {
- // AbstractType is an abstract class.
- UNREACHABLE();
-}
-
RawAbstractType* AbstractType::InstantiateFrom(
const TypeArguments& instantiator_type_arguments,
const TypeArguments& function_type_arguments,
@@ -16586,19 +16401,6 @@
return NULL;
}
-RawAbstractType* AbstractType::CloneUnfinalized() const {
- // AbstractType is an abstract class.
- UNREACHABLE();
- return NULL;
-}
-
-RawAbstractType* AbstractType::CloneUninstantiated(const Class& new_owner,
- TrailPtr trail) const {
- // AbstractType is an abstract class.
- UNREACHABLE();
- return NULL;
-}
-
RawAbstractType* AbstractType::Canonicalize(TrailPtr trail) const {
// AbstractType is an abstract class.
UNREACHABLE();
@@ -16753,37 +16555,31 @@
}
// Print the name of a typedef as a regular, possibly parameterized, class.
}
- if (IsResolved() || !cls.IsMixinApplication()) {
- // Do not print the full vector, but only the declared type parameters.
- num_type_params = cls.NumTypeParameters();
+ // Do not print the full vector, but only the declared type parameters.
+ num_type_params = cls.NumTypeParameters();
+ if (name_visibility == kInternalName) {
+ class_name = cls.Name();
+ } else {
+ ASSERT(name_visibility == kUserVisibleName);
+ // Map internal types to their corresponding public interfaces.
+ class_name = cls.UserVisibleName();
+ }
+ if (num_type_params > num_args) {
+ first_type_param_index = 0;
+ if (!IsFinalized() || IsBeingFinalized()) {
+ // TODO(regis): Check if this is dead code.
+ num_type_params = num_args;
} else {
- // Do not print the type parameters of an unresolved mixin application,
- // since it would prematurely trigger the application of the mixin type.
- num_type_params = 0;
+ ASSERT(num_args == 0); // Type is raw.
}
- if (name_visibility == kInternalName) {
- class_name = cls.Name();
+ } else {
+ // The actual type argument vector can be longer than necessary, because
+ // of type optimizations.
+ if (IsFinalized() && cls.is_type_finalized()) {
+ first_type_param_index = cls.NumTypeArguments() - num_type_params;
} else {
- ASSERT(name_visibility == kUserVisibleName);
- // Map internal types to their corresponding public interfaces.
- class_name = cls.UserVisibleName();
+ first_type_param_index = num_args - num_type_params;
}
- if (num_type_params > num_args) {
- first_type_param_index = 0;
- if (!IsFinalized() || IsBeingFinalized()) {
- // TODO(regis): Check if this is dead code.
- num_type_params = num_args;
- } else {
- ASSERT(num_args == 0); // Type is raw.
- }
- } else {
- // The actual type argument vector can be longer than necessary, because
- // of type optimizations.
- if (IsFinalized() && cls.is_type_finalized()) {
- first_type_param_index = cls.NumTypeArguments() - num_type_params;
- } else {
- first_type_param_index = num_args - num_type_params;
- }
}
GrowableHandlePtrArray<const String> pieces(zone, 4);
pieces.Add(class_name);
@@ -17184,7 +16980,7 @@
}
void Type::SetIsBeingFinalized() const {
- ASSERT(IsResolved() && !IsFinalized() && !IsBeingFinalized());
+ ASSERT(!IsFinalized() && !IsBeingFinalized());
set_type_state(RawType::kBeingFinalized);
}
@@ -17201,11 +16997,6 @@
StorePointer(&raw_ptr()->signature_, value.raw());
}
-void Type::SetIsResolved() const {
- ASSERT(!IsResolved());
- set_type_state(RawType::kResolved);
-}
-
classid_t Type::type_class_id() const {
return Smi::Value(raw_ptr()->type_class_id_);
}
@@ -17307,7 +17098,6 @@
if (IsFinalized()) {
instantiated_type.SetIsFinalized();
} else {
- instantiated_type.SetIsResolved();
if (IsBeingFinalized()) {
instantiated_type.SetIsBeingFinalized();
}
@@ -17335,7 +17125,6 @@
if (IsFunctionType() != other_type.IsFunctionType()) {
return false;
}
- ASSERT(IsResolved() && other_type.IsResolved());
if (type_class_id() != other_type.type_class_id()) {
return false;
}
@@ -17468,148 +17257,6 @@
return TypeArguments::Handle(arguments()).IsRecursive();
}
-void Type::SetScopeFunction(const Function& function) const {
- TypeArguments::Handle(arguments()).SetScopeFunction(function);
- if (IsFunctionType()) {
- const Function& sig_fun = Function::Handle(signature());
- sig_fun.set_parent_function(function);
- // No need to traverse result type and parameter types (and bounds, in case
- // sig_fun is generic), since they have sig_fun as scope function.
- }
-}
-
-RawAbstractType* Type::CloneUnfinalized() const {
- ASSERT(IsResolved());
- if (IsFinalized()) {
- return raw();
- }
- ASSERT(!IsBeingFinalized()); // Cloning must occur prior to finalization.
- Zone* zone = Thread::Current()->zone();
- const TypeArguments& type_args = TypeArguments::Handle(zone, arguments());
- const TypeArguments& type_args_clone =
- TypeArguments::Handle(zone, type_args.CloneUnfinalized());
- if (type_args_clone.raw() == type_args.raw()) {
- return raw();
- }
- const Type& clone = Type::Handle(
- zone,
- Type::New(Class::Handle(zone, type_class()), type_args, token_pos()));
- // Clone the signature if this type represents a function type.
- Function& fun = Function::Handle(zone, signature());
- if (!fun.IsNull()) {
- const Class& owner = Class::Handle(zone, fun.Owner());
- const Function& parent = Function::Handle(zone, fun.parent_function());
- Function& fun_clone =
- Function::Handle(zone, Function::NewSignatureFunction(
- owner, parent, TokenPosition::kNoSource));
- const TypeArguments& type_params =
- TypeArguments::Handle(zone, fun.type_parameters());
- if (!type_params.IsNull()) {
- const intptr_t num_type_params = type_params.Length();
- const TypeArguments& type_params_clone =
- TypeArguments::Handle(zone, TypeArguments::New(num_type_params));
- TypeParameter& type_param = TypeParameter::Handle(zone);
- for (intptr_t i = 0; i < num_type_params; i++) {
- type_param ^= type_params.TypeAt(i);
- type_param ^= type_param.CloneUnfinalized();
- type_params_clone.SetTypeAt(i, type_param);
- }
- fun_clone.set_type_parameters(type_params_clone);
- }
- AbstractType& type = AbstractType::Handle(zone, fun.result_type());
- type = type.CloneUnfinalized();
- fun_clone.set_result_type(type);
- const intptr_t num_params = fun.NumParameters();
- fun_clone.set_num_fixed_parameters(fun.num_fixed_parameters());
- fun_clone.SetNumOptionalParameters(fun.NumOptionalParameters(),
- fun.HasOptionalPositionalParameters());
- fun_clone.set_parameter_types(
- Array::Handle(Array::New(num_params, Heap::kOld)));
- for (intptr_t i = 0; i < num_params; i++) {
- type = fun.ParameterTypeAt(i);
- type = type.CloneUnfinalized();
- fun_clone.SetParameterTypeAt(i, type);
- }
- fun_clone.set_parameter_names(Array::Handle(zone, fun.parameter_names()));
- clone.set_signature(fun_clone);
- fun_clone.SetSignatureType(clone);
- }
- clone.SetIsResolved();
- return clone.raw();
-}
-
-RawAbstractType* Type::CloneUninstantiated(const Class& new_owner,
- TrailPtr trail) const {
- ASSERT(IsFinalized());
- if (IsInstantiated()) {
- return raw();
- }
- // We may recursively encounter a type already being cloned, because we clone
- // the upper bounds of its uninstantiated type arguments in the same pass.
- Zone* zone = Thread::Current()->zone();
- Type& clone = Type::Handle(zone);
- clone ^= OnlyBuddyInTrail(trail);
- if (!clone.IsNull()) {
- return clone.raw();
- }
- const Class& type_cls = Class::Handle(zone, type_class());
- clone = Type::New(type_cls, TypeArguments::Handle(zone), token_pos());
- // Clone the signature if this type represents a function type.
- const Function& fun = Function::Handle(zone, signature());
- if (!fun.IsNull()) {
- ASSERT(type_cls.IsTypedefClass() || type_cls.IsClosureClass());
- // If the scope class is not a typedef and if it is generic, it must be the
- // mixin class, set it to the new owner.
- const Function& parent = Function::Handle(zone, fun.parent_function());
- // TODO(regis): Is it safe to reuse the parent function with the old owner?
- Function& fun_clone = Function::Handle(
- zone, Function::NewSignatureFunction(new_owner, parent,
- TokenPosition::kNoSource));
- const TypeArguments& type_params =
- TypeArguments::Handle(zone, fun.type_parameters());
- if (!type_params.IsNull()) {
- const intptr_t num_type_params = type_params.Length();
- const TypeArguments& type_params_clone =
- TypeArguments::Handle(zone, TypeArguments::New(num_type_params));
- TypeParameter& type_param = TypeParameter::Handle(zone);
- for (intptr_t i = 0; i < num_type_params; i++) {
- type_param ^= type_params.TypeAt(i);
- type_param ^= type_param.CloneUninstantiated(new_owner, trail);
- type_params_clone.SetTypeAt(i, type_param);
- }
- fun_clone.set_type_parameters(type_params_clone);
- }
- AbstractType& type = AbstractType::Handle(zone, fun.result_type());
- type = type.CloneUninstantiated(new_owner, trail);
- fun_clone.set_result_type(type);
- const intptr_t num_params = fun.NumParameters();
- fun_clone.set_num_fixed_parameters(fun.num_fixed_parameters());
- fun_clone.SetNumOptionalParameters(fun.NumOptionalParameters(),
- fun.HasOptionalPositionalParameters());
- fun_clone.set_parameter_types(
- Array::Handle(Array::New(num_params, Heap::kOld)));
- for (intptr_t i = 0; i < num_params; i++) {
- type = fun.ParameterTypeAt(i);
- type = type.CloneUninstantiated(new_owner, trail);
- fun_clone.SetParameterTypeAt(i, type);
- }
- fun_clone.set_parameter_names(Array::Handle(zone, fun.parameter_names()));
- clone.set_signature(fun_clone);
- }
- TypeArguments& type_args = TypeArguments::Handle(zone, arguments());
- if (!type_args.IsNull()) {
- // Upper bounds of uninstantiated type arguments may form a cycle.
- if (type_args.IsRecursive() || !type_args.IsInstantiated()) {
- AddOnlyBuddyToTrail(&trail, clone);
- }
- type_args = type_args.CloneUninstantiated(new_owner, trail);
- clone.set_arguments(type_args);
- }
- clone.SetIsFinalized();
- clone ^= clone.Canonicalize();
- return clone.raw();
-}
-
RawAbstractType* Type::Canonicalize(TrailPtr trail) const {
ASSERT(IsFinalized());
if (IsCanonical()) {
@@ -17935,12 +17582,6 @@
return !ref_type.IsNull() && ref_type.IsEquivalent(other, trail);
}
-void TypeRef::SetScopeFunction(const Function& function) const {
- // TypeRefs are created during finalization, when scope functions have
- // already been adjusted.
- UNREACHABLE();
-}
-
RawTypeRef* TypeRef::InstantiateFrom(
const TypeArguments& instantiator_type_arguments,
const TypeArguments& function_type_arguments,
@@ -17969,26 +17610,6 @@
return instantiated_type_ref.raw();
}
-RawTypeRef* TypeRef::CloneUninstantiated(const Class& new_owner,
- TrailPtr trail) const {
- TypeRef& cloned_type_ref = TypeRef::Handle();
- cloned_type_ref ^= OnlyBuddyInTrail(trail);
- if (!cloned_type_ref.IsNull()) {
- return cloned_type_ref.raw();
- }
- cloned_type_ref = TypeRef::New();
- AddOnlyBuddyToTrail(&trail, cloned_type_ref);
- AbstractType& ref_type = AbstractType::Handle(type());
- ASSERT(!ref_type.IsNull() && !ref_type.IsTypeRef());
- AbstractType& cloned_ref_type = AbstractType::Handle();
- cloned_ref_type = ref_type.CloneUninstantiated(new_owner, trail);
- ASSERT(!cloned_ref_type.IsTypeRef());
- cloned_type_ref.set_type(cloned_ref_type);
- cloned_type_ref.SetTypeTestingStub(Instructions::Handle(
- TypeTestingStubGenerator::DefaultCodeForType(cloned_type_ref)));
- return cloned_type_ref.raw();
-}
-
void TypeRef::set_type(const AbstractType& value) const {
ASSERT(value.IsFunctionType() || value.HasTypeClass());
ASSERT(!value.IsTypeRef());
@@ -18193,49 +17814,6 @@
// not only happens at run time, but also during type finalization.
}
-RawAbstractType* TypeParameter::CloneUnfinalized() const {
- if (IsFinalized()) {
- return raw();
- }
- // No need to clone bound, as it is not part of the finalization state.
- return TypeParameter::New(Class::Handle(parameterized_class()),
- Function::Handle(parameterized_function()), index(),
- String::Handle(name()),
- AbstractType::Handle(bound()), token_pos());
-}
-
-RawAbstractType* TypeParameter::CloneUninstantiated(const Class& new_owner,
- TrailPtr trail) const {
- ASSERT(IsFinalized());
- Thread* thread = Thread::Current();
- Zone* zone = thread->zone();
- TypeParameter& clone = TypeParameter::Handle(zone);
- clone ^= OnlyBuddyInTrail(trail);
- if (!clone.IsNull()) {
- return clone.raw();
- }
- intptr_t new_index = index();
- AbstractType& upper_bound = AbstractType::Handle(zone, bound());
- const Function& fun = Function::Handle(zone, parameterized_function());
- Class& cls = Class::Handle(zone, parameterized_class());
- if (!cls.IsNull()) {
- ASSERT(fun.IsNull());
- new_index += new_owner.NumTypeArguments() - cls.NumTypeArguments();
- cls = new_owner.raw();
- } else {
- ASSERT(IsFunctionTypeParameter());
- // Only the bounds of function type parameters need cloning.
- }
- clone = TypeParameter::New(cls, fun, new_index, String::Handle(zone, name()),
- upper_bound, // Not cloned yet.
- token_pos());
- clone.SetIsFinalized();
- AddOnlyBuddyToTrail(&trail, clone);
- upper_bound = upper_bound.CloneUninstantiated(new_owner, trail);
- clone.set_bound(upper_bound);
- return clone.raw();
-}
-
void TypeParameter::EnumerateURIs(URIs* uris) const {
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
@@ -18352,64 +17930,6 @@
}
}
-TokenPosition MixinAppType::token_pos() const {
- return AbstractType::Handle(MixinTypeAt(0)).token_pos();
-}
-
-intptr_t MixinAppType::Depth() const {
- return Array::Handle(mixin_types()).Length();
-}
-
-RawString* MixinAppType::Name() const {
- return String::New("MixinAppType");
-}
-
-const char* MixinAppType::ToCString() const {
- const char* format = "MixinAppType: super type: %s; first mixin type: %s";
- const char* super_type_cstr =
- String::Handle(AbstractType::Handle(super_type()).Name()).ToCString();
- const char* first_mixin_type_cstr =
- String::Handle(AbstractType::Handle(MixinTypeAt(0)).Name()).ToCString();
- intptr_t len =
- Utils::SNPrint(NULL, 0, format, super_type_cstr, first_mixin_type_cstr) +
- 1;
- char* chars = Thread::Current()->zone()->Alloc<char>(len);
- Utils::SNPrint(chars, len, format, super_type_cstr, first_mixin_type_cstr);
- return chars;
-}
-
-RawAbstractType* MixinAppType::MixinTypeAt(intptr_t depth) const {
- return AbstractType::RawCast(Array::Handle(mixin_types()).At(depth));
-}
-
-void MixinAppType::set_super_type(const AbstractType& value) const {
- StorePointer(&raw_ptr()->super_type_, value.raw());
-}
-
-void MixinAppType::set_mixin_types(const Array& value) const {
- StorePointer(&raw_ptr()->mixin_types_, value.raw());
-}
-
-RawMixinAppType* MixinAppType::New() {
- // MixinAppType objects do not survive finalization, so allocate
- // on new heap.
- RawObject* raw = Object::Allocate(MixinAppType::kClassId,
- MixinAppType::InstanceSize(), Heap::kOld);
- return reinterpret_cast<RawMixinAppType*>(raw);
-}
-
-RawMixinAppType* MixinAppType::New(const AbstractType& super_type,
- const Array& mixin_types) {
- Zone* Z = Thread::Current()->zone();
- const MixinAppType& result = MixinAppType::Handle(Z, MixinAppType::New());
- result.set_super_type(super_type);
- result.set_mixin_types(mixin_types);
-
- result.SetTypeTestingStub(Instructions::Handle(
- Z, TypeTestingStubGenerator::DefaultCodeForType(result)));
- return result.raw();
-}
-
RawInstance* Number::CheckAndCanonicalize(Thread* thread,
const char** error_str) const {
intptr_t cid = GetClassId();
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index e4d0987..13d9057 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -953,12 +953,6 @@
// classes.
RawClass* SuperClass(bool original_classes = false) const;
- RawType* mixin() const { return raw_ptr()->mixin_; }
- void set_mixin(const Type& value) const;
-
- // Note this returns false for mixin application aliases.
- bool IsMixinApplication() const;
-
RawClass* GetPatchClass() const;
// Interfaces is an array of Types.
@@ -1164,16 +1158,6 @@
bool is_const() const { return ConstBit::decode(raw_ptr()->state_bits_); }
void set_is_const() const;
- bool is_mixin_app_alias() const {
- return MixinAppAliasBit::decode(raw_ptr()->state_bits_);
- }
- void set_is_mixin_app_alias() const;
-
- bool is_mixin_type_applied() const {
- return MixinTypeAppliedBit::decode(raw_ptr()->state_bits_);
- }
- void set_is_mixin_type_applied() const;
-
// Tests if this is a mixin application class which was desugared
// to a normal class by kernel mixin transformation
// (pkg/kernel/lib/transformations/mixin_full_resolution.dart).
@@ -1377,10 +1361,6 @@
: public BitField<uint16_t, bool, kSynthesizedClassBit, 1> {};
class MarkedForParsingBit
: public BitField<uint16_t, bool, kMarkedForParsingBit, 1> {};
- class MixinAppAliasBit
- : public BitField<uint16_t, bool, kMixinAppAliasBit, 1> {};
- class MixinTypeAppliedBit
- : public BitField<uint16_t, bool, kMixinTypeAppliedBit, 1> {};
class FieldsMarkedNullableBit
: public BitField<uint16_t, bool, kFieldsMarkedNullableBit, 1> {};
class CycleFreeBit : public BitField<uint16_t, bool, kCycleFreeBit, 1> {};
@@ -2847,10 +2827,6 @@
bool allow_add = true) const;
#endif
- // Allocate new function object, clone values from this function. The
- // owner of the clone is new_owner.
- RawFunction* Clone(const Class& new_owner) const;
-
// Slow function, use in asserts to track changes in important library
// functions.
int32_t SourceFingerprint() const;
@@ -3267,9 +3243,6 @@
TokenPosition end_token_pos);
// Allocate new field object, clone values from this field. The
- // owner of the clone is new_owner.
- RawField* Clone(const Class& new_owner) const;
- // Allocate new field object, clone values from this field. The
// original is specified.
RawField* Clone(const Field& original) const;
@@ -6121,27 +6094,12 @@
bool CanShareInstantiatorTypeArguments(const Class& instantiator_class) const;
bool CanShareFunctionTypeArguments(const Function& function) const;
- // Return true if all types of this vector are respectively, resolved,
- // finalized, or bounded.
- bool IsResolved() const;
+ // Return true if all types of this vector are finalized.
bool IsFinalized() const;
// Return true if this vector contains a recursive type argument.
bool IsRecursive() const;
- // Set the scope of this type argument vector to the given function.
- void SetScopeFunction(const Function& function) const;
-
- // Clone this type argument vector and clone all unfinalized type arguments.
- // Finalized type arguments are shared.
- RawTypeArguments* CloneUnfinalized() const;
-
- // Clone this type argument vector and clone all uninstantiated type
- // arguments, changing the class owner of type parameters.
- // Instantiated type arguments are shared.
- RawTypeArguments* CloneUninstantiated(const Class& new_owner,
- TrailPtr trail = NULL) const;
-
// Canonicalize only if instantiated, otherwise returns 'this'.
RawTypeArguments* Canonicalize(TrailPtr trail = NULL) const;
@@ -6257,8 +6215,6 @@
virtual void SetIsFinalized() const;
virtual bool IsBeingFinalized() const;
virtual void SetIsBeingFinalized() const;
- virtual bool IsResolved() const;
- virtual void SetIsResolved() const;
virtual bool HasTypeClass() const { return type_class_id() != kIllegalCid; }
virtual classid_t type_class_id() const;
virtual RawClass* type_class() const;
@@ -6278,9 +6234,6 @@
virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
virtual bool IsRecursive() const;
- // Set the scope of this type to the given function.
- virtual void SetScopeFunction(const Function& function) const;
-
// Check if this type represents a function type.
virtual bool IsFunctionType() const { return false; }
@@ -6302,19 +6255,6 @@
TrailPtr instantiation_trail,
Heap::Space space) const;
- // Return a clone of this unfinalized type or the type itself if it is
- // already finalized. Apply recursively to type arguments, i.e. finalized
- // type arguments of an unfinalized type are not cloned, but shared.
- virtual RawAbstractType* CloneUnfinalized() const;
-
- // Return a clone of this uninstantiated type where all references to type
- // parameters are replaced with references to type parameters of the same name
- // but belonging to the new owner class.
- // Apply recursively to type arguments, i.e. instantiated type arguments of
- // an uninstantiated type are not cloned, but shared.
- virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
- TrailPtr trail = NULL) const;
-
virtual RawInstance* CheckAndCanonicalize(Thread* thread,
const char** error_str) const {
return Canonicalize();
@@ -6504,10 +6444,6 @@
return raw_ptr()->type_state_ == RawType::kBeingFinalized;
}
virtual void SetIsBeingFinalized() const;
- virtual bool IsResolved() const {
- return raw_ptr()->type_state_ >= RawType::kResolved;
- }
- virtual void SetIsResolved() const;
virtual bool HasTypeClass() const {
ASSERT(type_class_id() != kIllegalCid);
return true;
@@ -6523,7 +6459,6 @@
TrailPtr trail = NULL) const;
virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
virtual bool IsRecursive() const;
- virtual void SetScopeFunction(const Function& function) const;
// If signature is not null, this type represents a function type. Note that
// the signature fully represents the type and type arguments can be ignored.
// However, in case of a generic typedef, they document how the typedef class
@@ -6541,9 +6476,6 @@
intptr_t num_free_fun_type_params,
TrailPtr instantiation_trail,
Heap::Space space) const;
- virtual RawAbstractType* CloneUnfinalized() const;
- virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
- TrailPtr trail = NULL) const;
virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const;
#if defined(DEBUG)
// Check if type is canonical.
@@ -6647,7 +6579,6 @@
const AbstractType& ref_type = AbstractType::Handle(type());
return ref_type.IsNull() || ref_type.IsBeingFinalized();
}
- virtual bool IsResolved() const { return true; }
virtual bool HasTypeClass() const {
return (type() != AbstractType::null()) &&
AbstractType::Handle(type()).HasTypeClass();
@@ -6671,15 +6602,12 @@
TrailPtr trail = NULL) const;
virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
virtual bool IsRecursive() const { return true; }
- virtual void SetScopeFunction(const Function& function) const;
virtual RawTypeRef* InstantiateFrom(
const TypeArguments& instantiator_type_arguments,
const TypeArguments& function_type_arguments,
intptr_t num_free_fun_type_params,
TrailPtr instantiation_trail,
Heap::Space space) const;
- virtual RawTypeRef* CloneUninstantiated(const Class& new_owner,
- TrailPtr trail = NULL) const;
virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const;
#if defined(DEBUG)
// Check if typeref is canonical.
@@ -6720,7 +6648,6 @@
}
virtual void SetIsFinalized() const;
virtual bool IsBeingFinalized() const { return false; }
- virtual bool IsResolved() const { return true; }
virtual bool HasTypeClass() const { return false; }
virtual classid_t type_class_id() const { return kIllegalCid; }
classid_t parameterized_class_id() const;
@@ -6745,16 +6672,12 @@
TrailPtr trail = NULL) const;
virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
virtual bool IsRecursive() const { return false; }
- virtual void SetScopeFunction(const Function& function) const {}
virtual RawAbstractType* InstantiateFrom(
const TypeArguments& instantiator_type_arguments,
const TypeArguments& function_type_arguments,
intptr_t num_free_fun_type_params,
TrailPtr instantiation_trail,
Heap::Space space) const;
- virtual RawAbstractType* CloneUnfinalized() const;
- virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
- TrailPtr trail = NULL) const;
virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const {
return raw();
}
@@ -6795,53 +6718,6 @@
friend class ClearTypeHashVisitor;
};
-// A MixinAppType represents a parsed mixin application clause, e.g.
-// "S<T> with M<U>, N<V>".
-// MixinAppType objects do not survive finalization, so they do not
-// need to be written to and read from snapshots.
-// The class finalizer creates synthesized classes S&M and S&M&N if they do not
-// yet exist in the library declaring the mixin application clause.
-class MixinAppType : public AbstractType {
- public:
- // A MixinAppType object is unfinalized by definition, since it is replaced at
- // class finalization time with a finalized Type object.
- virtual bool IsFinalized() const { return false; }
- virtual bool IsResolved() const { return false; }
- virtual bool HasTypeClass() const { return false; }
- virtual RawString* Name() const;
- virtual TokenPosition token_pos() const;
-
- // Returns the mixin composition depth of this mixin application type.
- intptr_t Depth() const;
-
- // Returns the declared super type of the mixin application, which will also
- // be the super type of the first synthesized class, e.g. class "S&M" will
- // refer to super type "S<T>".
- RawAbstractType* super_type() const { return raw_ptr()->super_type_; }
-
- // Returns the mixin type at the given mixin composition depth, e.g. N<V> at
- // depth 0 and M<U> at depth 1.
- RawAbstractType* MixinTypeAt(intptr_t depth) const;
-
- static intptr_t InstanceSize() {
- return RoundedAllocationSize(sizeof(RawMixinAppType));
- }
-
- static RawMixinAppType* New(const AbstractType& super_type,
- const Array& mixin_types);
-
- private:
- void set_super_type(const AbstractType& value) const;
-
- RawArray* mixin_types() const { return raw_ptr()->mixin_types_; }
- void set_mixin_types(const Array& value) const;
-
- static RawMixinAppType* New();
-
- FINAL_HEAP_OBJECT_IMPLEMENTATION(MixinAppType, AbstractType);
- friend class Class;
-};
-
class Number : public Instance {
public:
// TODO(iposva): Add more useful Number methods.
diff --git a/runtime/vm/object_service.cc b/runtime/vm/object_service.cc
index 4071bf0..fa7f4b8 100644
--- a/runtime/vm/object_service.cc
+++ b/runtime/vm/object_service.cc
@@ -107,8 +107,10 @@
if (!superType.IsNull()) {
jsobj.AddProperty("superType", superType);
}
- const Type& mix = Type::Handle(mixin());
- if (!mix.IsNull()) {
+ const Array& interface_array = Array::Handle(interfaces());
+ if (is_transformed_mixin_application()) {
+ Type& mix = Type::Handle();
+ mix ^= interface_array.At(interface_array.Length() - 1);
jsobj.AddProperty("mixin", mix);
}
jsobj.AddProperty("library", Object::Handle(library()));
@@ -118,7 +120,6 @@
}
{
JSONArray interfaces_array(&jsobj, "interfaces");
- const Array& interface_array = Array::Handle(interfaces());
Type& interface_type = Type::Handle();
if (!interface_array.IsNull()) {
for (intptr_t i = 0; i < interface_array.Length(); ++i) {
@@ -485,9 +486,7 @@
Class& klass = Class::Handle();
while (class_iter.HasNext()) {
klass = class_iter.GetNextClass();
- if (!klass.IsMixinApplication()) {
- jsarr.AddValue(klass);
- }
+ jsarr.AddValue(klass);
}
}
{
@@ -1154,10 +1153,6 @@
jsobj.AddProperty("bound", upper_bound);
}
-void MixinAppType::PrintJSONImpl(JSONStream* stream, bool ref) const {
- UNREACHABLE();
-}
-
void Number::PrintJSONImpl(JSONStream* stream, bool ref) const {
UNREACHABLE();
}
diff --git a/runtime/vm/raw_object.cc b/runtime/vm/raw_object.cc
index cc8e6d6..e0d7945 100644
--- a/runtime/vm/raw_object.cc
+++ b/runtime/vm/raw_object.cc
@@ -386,7 +386,6 @@
REGULAR_VISITOR(Type)
REGULAR_VISITOR(TypeRef)
REGULAR_VISITOR(TypeParameter)
-REGULAR_VISITOR(MixinAppType)
REGULAR_VISITOR(PatchClass)
COMPRESSED_VISITOR(Closure)
REGULAR_VISITOR(ClosureData)
diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h
index a383cca..93cde94 100644
--- a/runtime/vm/raw_object.h
+++ b/runtime/vm/raw_object.h
@@ -60,7 +60,6 @@
V(Type) \
V(TypeRef) \
V(TypeParameter) \
- V(MixinAppType) \
V(Closure) \
V(Number) \
V(Integer) \
@@ -908,7 +907,6 @@
RawLibrary* library_;
RawTypeArguments* type_parameters_; // Array of TypeParameter.
RawAbstractType* super_type_;
- RawType* mixin_; // Generic mixin type, e.g. M<T>, not M<int>.
RawFunction* signature_function_; // Associated function for typedef class.
RawArray* constants_; // Canonicalized const instances of this class.
RawType* canonical_type_; // Canonical type for this class.
@@ -2004,7 +2002,6 @@
protected:
enum TypeState {
kAllocated, // Initial state.
- kResolved, // Type class and type arguments resolved.
kBeingFinalized, // In the process of being finalized.
kFinalizedInstantiated, // Instantiated type ready for use.
kFinalizedUninstantiated, // Uninstantiated type ready for use.
@@ -2076,16 +2073,6 @@
friend class CidRewriteVisitor;
};
-class RawMixinAppType : public RawAbstractType {
- private:
- RAW_HEAP_OBJECT_IMPLEMENTATION(MixinAppType);
-
- VISIT_FROM(RawObject*, super_type_);
- RawAbstractType* super_type_;
- RawArray* mixin_types_; // Array of AbstractType.
- VISIT_TO(RawObject*, mixin_types_);
-};
-
class RawClosure : public RawInstance {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(Closure);
diff --git a/runtime/vm/raw_object_fields.cc b/runtime/vm/raw_object_fields.cc
index 1802505..ed51255 100644
--- a/runtime/vm/raw_object_fields.cc
+++ b/runtime/vm/raw_object_fields.cc
@@ -20,7 +20,6 @@
F(Class, library_) \
F(Class, type_parameters_) \
F(Class, super_type_) \
- F(Class, mixin_) \
F(Class, signature_function_) \
F(Class, constants_) \
F(Class, canonical_type_) \
@@ -147,8 +146,6 @@
F(TypeParameter, hash_) \
F(TypeParameter, bound_) \
F(TypeParameter, parameterized_function_) \
- F(MixinAppType, super_type_) \
- F(MixinAppType, mixin_types_) \
F(Closure, instantiator_type_arguments_) \
F(Closure, function_type_arguments_) \
F(Closure, delayed_type_arguments_) \
diff --git a/runtime/vm/raw_object_snapshot.cc b/runtime/vm/raw_object_snapshot.cc
index a67660e..286beb6 100644
--- a/runtime/vm/raw_object_snapshot.cc
+++ b/runtime/vm/raw_object_snapshot.cc
@@ -297,22 +297,6 @@
writer->WriteObjectImpl(param_class, kAsReference);
}
-RawMixinAppType* MixinAppType::ReadFrom(SnapshotReader* reader,
- intptr_t object_id,
- intptr_t tags,
- Snapshot::Kind kind,
- bool as_reference) {
- UNREACHABLE(); // MixinAppType objects do not survive finalization.
- return MixinAppType::null();
-}
-
-void RawMixinAppType::WriteTo(SnapshotWriter* writer,
- intptr_t object_id,
- Snapshot::Kind kind,
- bool as_reference) {
- UNREACHABLE(); // MixinAppType objects do not survive finalization.
-}
-
RawTypeArguments* TypeArguments::ReadFrom(SnapshotReader* reader,
intptr_t object_id,
intptr_t tags,
diff --git a/runtime/vm/service.cc b/runtime/vm/service.cc
index c9f7323..acf8b6f 100644
--- a/runtime/vm/service.cc
+++ b/runtime/vm/service.cc
@@ -4666,7 +4666,7 @@
}
{
JSONArray internals(&map, "Type");
- for (intptr_t id = kAbstractTypeCid; id <= kMixinAppTypeCid; ++id) {
+ for (intptr_t id = kAbstractTypeCid; id <= kTypeParameterCid; ++id) {
DEFINE_ADD_VALUE_F(id);
}
}
diff --git a/runtime/vm/service.h b/runtime/vm/service.h
index ca29775..ace6da3 100644
--- a/runtime/vm/service.h
+++ b/runtime/vm/service.h
@@ -15,7 +15,7 @@
namespace dart {
#define SERVICE_PROTOCOL_MAJOR_VERSION 3
-#define SERVICE_PROTOCOL_MINOR_VERSION 12
+#define SERVICE_PROTOCOL_MINOR_VERSION 13
class Array;
class EmbedderServiceHandler;
diff --git a/runtime/vm/service/service.md b/runtime/vm/service/service.md
index 50b2691c..00f1b66 100644
--- a/runtime/vm/service/service.md
+++ b/runtime/vm/service/service.md
@@ -1,8 +1,8 @@
-# Dart VM Service Protocol 3.12
+# Dart VM Service Protocol 3.13
> Please post feedback to the [observatory-discuss group][discuss-list]
-This document describes of _version 3.12_ of the Dart VM Service Protocol. This
+This document describes of _version 3.13_ of the Dart VM Service Protocol. This
protocol is used to communicate with a running Dart Virtual Machine.
To use the Service Protocol, start the VM with the *--observe* flag.
@@ -2731,5 +2731,6 @@
3.10 | Add 'invoke'.
3.11 | Rename 'invoke' parameter 'receiverId' to 'targetId.
3.12 | Add 'getScripts' RPC and `ScriptList` object.
+3.13 | Class 'mixin' field now properly set for kernel transformed mixin applications.
[discuss-list]: https://groups.google.com/a/dartlang.org/forum/#!forum/observatory-discuss
diff --git a/runtime/vm/service/service_dev.md b/runtime/vm/service/service_dev.md
index afb751c..869811e 100644
--- a/runtime/vm/service/service_dev.md
+++ b/runtime/vm/service/service_dev.md
@@ -1,8 +1,8 @@
-# Dart VM Service Protocol 3.13-dev
+# Dart VM Service Protocol 3.14-dev
> Please post feedback to the [observatory-discuss group][discuss-list]
-This document describes of _version 3.13-dev_ of the Dart VM Service Protocol. This
+This document describes of _version 3.14-dev_ of the Dart VM Service Protocol. This
protocol is used to communicate with a running Dart Virtual Machine.
To use the Service Protocol, start the VM with the *--observe* flag.
@@ -2731,5 +2731,6 @@
3.10 | Add 'invoke'.
3.11 | Rename 'invoke' parameter 'receiverId' to 'targetId.
3.12 | Add 'getScripts' RPC and `ScriptList` object.
+3.13 | Class 'mixin' field now properly set for kernel transformed mixin applications.
[discuss-list]: https://groups.google.com/a/dartlang.org/forum/#!forum/observatory-discuss
diff --git a/runtime/vm/snapshot.h b/runtime/vm/snapshot.h
index 14eeb06..1432259 100644
--- a/runtime/vm/snapshot.h
+++ b/runtime/vm/snapshot.h
@@ -65,7 +65,6 @@
class RawLocalVarDescriptors;
class RawMegamorphicCache;
class RawMint;
-class RawMixinAppType;
class RawNamespace;
class RawObject;
class RawObjectPool;
@@ -463,7 +462,6 @@
friend class LibraryPrefix;
friend class LinkedHashMap;
friend class MirrorReference;
- friend class MixinAppType;
friend class Namespace;
friend class PatchClass;
friend class RedirectionData;
diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h
index 933b83f5..536ad2b 100644
--- a/runtime/vm/symbols.h
+++ b/runtime/vm/symbols.h
@@ -167,7 +167,6 @@
V(_Type, "_Type") \
V(_TypeRef, "_TypeRef") \
V(_TypeParameter, "_TypeParameter") \
- V(_MixinAppType, "_MixinAppType") \
V(TypeArguments, "TypeArguments") \
V(Patch, "patch") \
V(Pragma, "pragma") \
diff --git a/runtime/vm/type_testing_stubs.cc b/runtime/vm/type_testing_stubs.cc
index 933742d..864d893 100644
--- a/runtime/vm/type_testing_stubs.cc
+++ b/runtime/vm/type_testing_stubs.cc
@@ -117,7 +117,6 @@
return should_specialize ? StubCode::LazySpecializeTypeTest().instructions()
: StubCode::DefaultTypeTest().instructions();
} else {
- ASSERT(type.IsMixinAppType());
return StubCode::UnreachableTypeTest().instructions();
}
}
