Revert "Add typedef AST node boilerplate."

pkg/kernel/lib/ast.dart

 // Copyright (c) 2016, 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.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 210 matching lines @@
     }
     return node as Constructor;
   }
 
   Procedure get asProcedure {
     if (node == null) {
       throw '$this is not bound to an AST node. A procedure was expected';
     }
     return node as Procedure;
   }
-
-  Typedef get asTypedef {
-    if (node == null) {
-      throw '$this is not bound to an AST node. A typedef was expected';
-    }
-    return node as Typedef;
-  }
 }
 
 // ------------------------------------------------------------------------
 //                      LIBRARIES and CLASSES
 // ------------------------------------------------------------------------
 
 class Library extends NamedNode implements Comparable<Library> {
   /// An import path to this library.
   ///
   /// The [Uri] should have the `dart`, `package`, `app`, or `file` scheme.
@@ skipping 10 matching lines @@
   /// Classes of an external library are loaded at one of the [ClassLevel]s
   /// other than [ClassLevel.Body].  Members in an external library have no
   /// body, but have their typed interface present.
   ///
   /// If the libary is non-external, then its classes are at [ClassLevel.Body]
   /// and all members are loaded.
   bool isExternal;
 
   String name;
   final List<DeferredImport> deferredImports;
-  final List<Typedef> typedefs;
   final List<Class> classes;
   final List<Procedure> procedures;
   final List<Field> fields;
 
   Library(this.importUri,
       {this.name,
       this.isExternal: false,
       List<DeferredImport> imports,
-      List<Typedef> typedefs,
       List<Class> classes,
       List<Procedure> procedures,
       List<Field> fields,
       this.fileUri,
       Reference reference})
       : this.deferredImports = imports ?? <DeferredImport>[],
-        this.typedefs = typedefs ?? <Typedef>[],
         this.classes = classes ?? <Class>[],
         this.procedures = procedures ?? <Procedure>[],
         this.fields = fields ?? <Field>[],
         super(reference) {
-    setParents(this.deferredImports, this);
-    setParents(this.typedefs, this);
     setParents(this.classes, this);
     setParents(this.procedures, this);
     setParents(this.fields, this);
   }
 
   /// Returns the top-level fields and procedures defined in this library.
   ///
   /// This getter is for convenience, not efficiency.  Consider manually
   /// iterating the members to speed up code in production.
   Iterable<Member> get members =>
       <Iterable<Member>>[fields, procedures].expand((x) => x);
 
   void addMember(Member member) {
     member.parent = this;
     if (member is Procedure) {
       procedures.add(member);
     } else if (member is Field) {
       fields.add(member);
     } else {
       throw new ArgumentError(member);
     }
   }
 
   void addClass(Class class_) {
     class_.parent = this;
     classes.add(class_);
   }
 
-  void addTypedef(Typedef typedef_) {
-    typedef_.parent = this;
-    typedefs.add(typedef_);
-  }
-
   void computeCanonicalNames() {
     assert(canonicalName != null);
-    for (var typedef_ in typedefs) {
-      canonicalName.getChildFromTypedef(typedef_).bindTo(typedef_.reference);
-    }
     for (var field in fields) {
       canonicalName.getChildFromMember(field).bindTo(field.reference);
     }
     for (var member in procedures) {
       canonicalName.getChildFromMember(member).bindTo(member.reference);
     }
     for (var class_ in classes) {
       canonicalName.getChild(class_.name).bindTo(class_.reference);
       class_.computeCanonicalNames();
     }
   }
 
   accept(TreeVisitor v) => v.visitLibrary(this);
 
   visitChildren(Visitor v) {
-    visitList(deferredImports, v);
-    visitList(typedefs, v);
     visitList(classes, v);
     visitList(procedures, v);
     visitList(fields, v);
   }
 
   transformChildren(Transformer v) {
-    transformList(deferredImports, v, this);
-    transformList(typedefs, v, this);
     transformList(classes, v, this);
     transformList(procedures, v, this);
     transformList(fields, v, this);
   }
 
   static int _libraryIdCounter = 0;
   int _libraryId = ++_libraryIdCounter;
 
   int compareTo(Library other) => _libraryId - other._libraryId;
 
@@ skipping 19 matching lines @@
   Library get enclosingLibrary => parent;
   Library get importedLibrary => importedLibraryReference.asLibrary;
 
   accept(TreeVisitor v) => v.visitDeferredImport(this);
 
   visitChildren(Visitor v) {}
 
   transformChildren(Transformer v) {}
 }
 
-/// Declaration of a type alias.
-class Typedef extends NamedNode {
-  /// The uri of the source file that contains the declaration of this typedef.
-  String fileUri;
-  List<Expression> annotations = const <Expression>[];
-  String name;
-  final List<TypeParameter> typeParameters;
-  DartType type;
-
-  Typedef(this.name, this.type,
-      {Reference reference, this.fileUri, List<TypeParameter> typeParameters})
-      : this.typeParameters = typeParameters ?? <TypeParameter>[],
-        super(reference) {
-    setParents(this.typeParameters, this);
-  }
-
-  Library get enclosingLibrary => parent;
-
-  accept(TreeVisitor v) {
-    return v.visitTypedef(this);
-  }
-
-  transformChildren(Transformer v) {
-    transformList(annotations, v, this);
-    transformList(typeParameters, v, this);
-    if (type != null) {
-      type = v.visitDartType(type);
-    }
-  }
-
-  visitChildren(Visitor v) {
-    visitList(annotations, v);
-    visitList(typeParameters, v);
-    type?.accept(v);
-  }
-
-  void addAnnotation(Expression node) {
-    if (annotations.isEmpty) {
-      annotations = <Expression>[];
-    }
-    annotations.add(node);
-    node.parent = this;
-  }
-}
-
 /// The degree to which the contents of a class have been loaded into memory.
 ///
 /// Each level imply the requirements of the previous ones.
 enum ClassLevel {
   /// Temporary loading level for internal use by IR producers.  Consumers of
   /// kernel code should not expect to see classes at this level.
   Temporary,
 
   /// The class may be used as a type, and it may contain members that are
   /// referenced from this build unit.
@@ skipping 3309 matching lines @@
 /// cyclic structures that are constructed by mutation.
 ///
 /// The `==` operator on [DartType]s compare based on type equality, not
 /// object identity.
 abstract class DartType extends Node {
   const DartType();
 
   accept(DartTypeVisitor v);
 
   bool operator ==(Object other);
-
-  /// If this is a typedef type, repeatedly unfolds its type definition until
-  /// the root term is not a typedef type, otherwise returns the type itself.
-  ///
-  /// Will never return a typedef type.
-  DartType get unalias => this;
-
-  /// If this is a typedef type, unfolds its type definition once, otherwise
-  /// returns the type itself.
-  DartType get unaliasOnce => this;
 }
 
 /// The type arising from invalid type annotations.
 ///
 /// Can usually be treated as 'dynamic', but should occasionally be handled
 /// differently, e.g. `x is ERROR` should evaluate to false.
 class InvalidType extends DartType {
   final int hashCode = 12345;
 
   const InvalidType();
@@ skipping 209 matching lines @@
     }
     hash = 0x3fffffff & (hash * 31 + returnType.hashCode);
     for (int i = 0; i < typeParameters.length; ++i) {
       // Remove the type parameters from the scope again.
       _temporaryHashCodeTable.remove(typeParameters[i]);
     }
     return hash;
   }
 }
 
-/// A use of a [Typedef] as a type.
-///
-/// The underlying type can be extracted using [unalias].
-class TypedefType extends DartType {
-  final Reference typedefReference;
-  final List<DartType> typeArguments;
-
-  TypedefType(Typedef typedefNode, [List<DartType> typeArguments])
-      : this.byReference(
-            typedefNode.reference, typeArguments ?? const <DartType>[]);
-
-  TypedefType.byReference(this.typedefReference, this.typeArguments);
-
-  Typedef get typedefNode => typedefReference.asTypedef;
-
-  accept(DartTypeVisitor v) => v.visitTypedefType(this);
-
-  visitChildren(Visitor v) {
-    visitList(typeArguments, v);
-    v.visitTypedefReference(typedefNode);
-  }
-
-  DartType get unaliasOnce {
-    return Substitution.fromTypedefType(this).substituteType(typedefNode.type);
-  }
-
-  DartType get unalias {
-    return unaliasOnce.unalias;
-  }
-
-  bool operator ==(Object other) {
-    if (identical(this, other)) return true;
-    if (other is TypedefType) {
-      if (typedefReference != other.typedefReference ||
-          typeArguments.length != other.typeArguments.length) {
-        return false;
-      }
-      for (int i = 0; i < typeArguments.length; ++i) {
-        if (typeArguments[i] != other.typeArguments[i]) return false;
-      }
-      return true;
-    }
-    return false;
-  }
-
-  int get hashCode {
-    int hash = 0x3fffffff & typedefNode.hashCode;
-    for (int i = 0; i < typeArguments.length; ++i) {
-      hash = 0x3fffffff & (hash * 31 + (hash ^ typeArguments[i].hashCode));
-    }
-    return hash;
-  }
-}
-
 /// A named parameter in [FunctionType].
 class NamedType extends Node implements Comparable<NamedType> {
   final String name;
   final DartType type;
 
   NamedType(this.name, this.type);
 
   bool operator ==(Object other) {
     return other is NamedType && name == other.name && type == other.type;
   }
@@ skipping 379 matching lines @@
 /// library has not been assigned a canonical name yet.
 ///
 /// Returns `null` if the library is `null`.
 CanonicalName getCanonicalNameOfLibrary(Library library) {
   if (library == null) return null;
   if (library.canonicalName == null) {
     throw '$library has no canonical name';
   }
   return library.canonicalName;
 }
-
-/// Returns the canonical name of [typedef_], or throws an exception if the
-/// typedef has not been assigned a canonical name yet.
-///
-/// Returns `null` if the typedef is `null`.
-CanonicalName getCanonicalNameOfTypedef(Typedef typedef_) {
-  if (typedef_ == null) return null;
-  if (typedef_.canonicalName == null) {
-    throw '$typedef_ has no canonical name';
-  }
-  return typedef_.canonicalName;
-}