Rename mixin typedef to mixin application alias in VM.

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 1468 matching lines @@
 
       // Lastly, set the type arguments of the mixin type and of the single
       // interface type.
       ASSERT(!mixin_type.IsFinalized());
       mixin_type.set_arguments(mixin_type_args);
       ASSERT(!interface.IsFinalized());
       interface.set_arguments(interface_type_args);
     }
     mixin_app_class.set_type_parameters(cloned_type_params);
   }
-  // If the mixin class is a mixin application typedef class, we insert a new
+  // 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_typedef()) {
-    ApplyMixinTypedef(mixin_app_class);
+  if (mixin_class.is_mixin_app_alias()) {
+    ApplyMixinAppAlias(mixin_app_class);
   }
 }
 
 
-/* Support for mixin typedef.
+/* Support for mixin alias.
 Consider the following example:
 
 class I<T> { }
 class J<T> { }
 class S<T> { }
 class M<T> { }
 class A<U, V> = Object with M<Map<U, V>> implements I<V>;
 class C<T, K> = S<T> with A<T, List<K>> implements J<K>;
 
-Before the call to ApplyMixinTypedef, the VM has already synthesized 2 mixin
+Before the call to ApplyMixinAppAlias, the VM has already synthesized 2 mixin
 application classes Object&M and S&A:
 
 Object&M<T> extends Object implements M<T> { ... members of M applied here ... }
 A<U, V> extends Object&M<Map<U, V>> implements I<V> { }
 
 S&A<T`, U, V> extends S<T`> implements A<U, V> { }
 C<T, K> 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 typedef A).
+type parameters of the alias A).
 
 Similarly, class C should be an alias of S&A instead of extending it.
 
 Since A is used as a mixin, it must extend Object. The fact that it extends
 Object&M must be hidden so that no error is wrongly reported.
 
-Now, A does not have any members to be mixed into S&A, because A is a typedef.
+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 ApplyMixinTypedef inserts another synthesized class S&A`
+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 S<T`> implements A<U, V> { }
 
 We now have:
 S&A`<T`, T> extends S<T`> implements M<T> { ... members of M applied here ... }
 S&A<T`, U, V> 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 of the first type parameter U of S&A must be at the finalized index
 of type parameter U of A.
 */
-// TODO(regis): The syntax does not use 'typedef' anymore. Rename to 'alias'?
-void ClassFinalizer::ApplyMixinTypedef(const Class& mixin_app_class) {
-  // If this mixin typedef is aliasing another mixin typedef, another class
+void ClassFinalizer::ApplyMixinAppAlias(const Class& mixin_app_class) {
+  // 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.
   AbstractType& super_type = AbstractType::Handle(mixin_app_class.super_type());
   const Type& mixin_type = Type::Handle(mixin_app_class.mixin());
   const Class& mixin_class = Class::Handle(mixin_type.type_class());
-  ASSERT(mixin_class.is_mixin_typedef());
+  ASSERT(mixin_class.is_mixin_app_alias());
   const Class& aliased_mixin_app_class = Class::Handle(
       mixin_class.SuperClass());
   const Type& aliased_mixin_type = Type::Handle(
       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(mixin_app_class.Name());
   inserted_class_name = String::Concat(inserted_class_name,
                                        Symbols::Backtick());
   const Library& library = Library::Handle(mixin_app_class.library());
   Class& inserted_class = Class::Handle(
       library.LookupLocalClass(inserted_class_name));
   if (inserted_class.IsNull()) {
     inserted_class_name = Symbols::New(inserted_class_name);
     const Script& script = Script::Handle(mixin_app_class.script());
     inserted_class = Class::New(
         inserted_class_name, script, mixin_app_class.token_pos());
     inserted_class.set_is_synthesized_class();
     library.AddClass(inserted_class);
 
     if (FLAG_trace_class_finalization) {
-      OS::Print("Creating mixin typedef application %s\n",
+      OS::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.
@@ skipping 12 matching lines @@
   }
 
   // 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
-  // typedef that are forwarding to the aliased mixin type, except
+  // 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 typedef class.
+  // 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.
   Class& super_class = Class::Handle(super_type.type_class());
   ASSERT(mixin_app_class.SuperClass() == super_class.raw());
   while (super_class.IsMixinApplication()) {
     super_class = super_class.SuperClass();
   }
   const intptr_t num_super_type_params = super_class.NumTypeParameters();
@@ skipping 54 matching lines @@
       } 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 a typedef.
-  mixin_app_class.set_is_mixin_typedef();
+  // 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) {
-    OS::Print("Inserting class %s to mixin typedef application %s "
+    OS::Print("Inserting class %s to mixin application alias %s "
               "with super type '%s'\n",
               inserted_class.ToCString(),
               mixin_app_class.ToCString(),
               String::Handle(super_type.Name()).ToCString());
   }
 }
 
 
 void ClassFinalizer::ApplyMixinType(const Class& mixin_app_class) {
   if (mixin_app_class.is_mixin_type_applied()) {
@@ skipping 18 matching lines @@
     const Script& script = Script::Handle(mixin_class.script());
     const String& class_name = String::Handle(mixin_class.Name());
     ReportError(Error::Handle(),  // No previous error.
                 script, mixin_class.token_pos(),
                 "mixin class '%s' illegally refers to itself",
                 class_name.ToCString());
   }
 
   // Check that the super class of the mixin class is class Object.
   Class& mixin_super_class = Class::Handle(mixin_class.SuperClass());
-  // Skip over mixin application typedef classes, which are aliases (but are
-  // implemented as subclasses) of the mixin application classes they name.
-  if (!mixin_super_class.IsNull() && mixin_class.is_mixin_typedef()) {
-    while (mixin_super_class.is_mixin_typedef()) {
+  // Skip over mixin application alias classes, which are implemented as
+  // subclasses of the mixin application classes they name.
+  if (!mixin_super_class.IsNull() && mixin_class.is_mixin_app_alias()) {
+    while (mixin_super_class.is_mixin_app_alias()) {
       mixin_super_class = mixin_super_class.SuperClass();
     }
     mixin_super_class = mixin_super_class.SuperClass();
   }
   if (mixin_super_class.IsNull() || !mixin_super_class.IsObjectClass()) {
     const Script& script = Script::Handle(mixin_app_class.script());
     const String& class_name = String::Handle(mixin_class.Name());
     ReportError(Error::Handle(),  // No previous error.
                 script, mixin_app_class.token_pos(),
                 "mixin class '%s' must extend class 'Object'",
@@ skipping 13 matching lines @@
               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 a typedef.
+  // mixin_app_class is an alias.
   mixin_type = mixin_app_class.mixin();
   ASSERT(!mixin_type.IsBeingFinalized());
   mixin_type ^=
       FinalizeType(mixin_app_class, mixin_type, kCanonicalizeWellFormed);
   // TODO(14453): Check for a malbounded mixin_type.
   mixin_app_class.set_mixin(mixin_type);
 }
 
 
 void ClassFinalizer::CreateForwardingConstructors(
@@ skipping 54 matching lines @@
 }
 
 
 void ClassFinalizer::ApplyMixinMembers(const Class& cls) {
   Isolate* isolate = Isolate::Current();
   const Type& mixin_type = Type::Handle(isolate, cls.mixin());
   ASSERT(!mixin_type.IsNull());
   ASSERT(mixin_type.HasResolvedTypeClass());
   const Class& mixin_cls = Class::Handle(isolate, mixin_type.type_class());
   mixin_cls.EnsureIsFinalized(isolate);
-  // If the mixin is a mixin application typedef class, there are no members to
+  // 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_typedef() ||
+  ASSERT(!mixin_cls.is_mixin_app_alias() ||
          Class::Handle(isolate, cls.SuperClass()).IsMixinApplication());
-  // A default constructor will be created for the typedef class.
+  // A default constructor will be created for the mixin app alias class.
 
   if (FLAG_trace_class_finalization) {
     OS::Print("Applying mixin members of %s to %s at pos %" Pd "\n",
               mixin_cls.ToCString(),
               cls.ToCString(),
               cls.token_pos());
   }
 
   const GrowableObjectArray& cloned_funcs =
       GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
@@ skipping 193 matching lines @@
     // the class conflict with inherited methods.
     ApplyMixinMembers(cls);
   }
   // Ensure super class is finalized.
   const Class& super = Class::Handle(cls.SuperClass());
   if (!super.IsNull()) {
     FinalizeClass(super);
   }
   // Mark as parsed and finalized.
   cls.Finalize();
-  // Mixin typedef classes may still lack their forwarding constructor.
-  if (cls.is_mixin_typedef() &&
+  // 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());
     CreateForwardingConstructors(cls, cloned_funcs);
     const Array& functions = Array::Handle(Array::MakeArray(cloned_funcs));
     cls.SetFunctions(functions);
   }
   // Every class should have at least a constructor, unless it is a top level
   // class or a signature class.
   ASSERT(cls.IsTopLevel() ||
@@ skipping 666 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart