Revert "Add typedef AST node boilerplate."

pkg/kernel/lib/verifier.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.
 library kernel.checks;
 
 import 'ast.dart';
 import 'transformations/flags.dart';
 
 void verifyProgram(Program program) {
   VerifyingVisitor.check(program);
@@ skipping 20 matching lines @@
       return "$file:${location.line}:${location.column}: Verification error:"
           " $details";
     } else {
       return "Verification error: $details\n"
           "Context: '$context'.\n"
           "Node: '$node'.";
     }
   }
 }
 
-enum TypedefState { Done, BeingChecked }
-
 /// Checks that a kernel program is well-formed.
 ///
 /// This does not include any kind of type checking.
 class VerifyingVisitor extends RecursiveVisitor {
   final Set<Class> classes = new Set<Class>();
-  final Set<Typedef> typedefs = new Set<Typedef>();
-  Set<TypeParameter> typeParametersInScope = new Set<TypeParameter>();
+  final Set<TypeParameter> typeParameters = new Set<TypeParameter>();
   final List<VariableDeclaration> variableStack = <VariableDeclaration>[];
-  final Map<Typedef, TypedefState> typedefState = <Typedef, TypedefState>{};
   bool classTypeParametersAreInScope = false;
 
   /// If true, relax certain checks for *outline* mode. For example, don't
   /// attempt to validate constructor initializers.
   bool isOutline = false;
 
   bool inCatchBlock = false;
 
   Member currentMember;
   Class currentClass;
   TreeNode currentParent;
 
   TreeNode get context => currentMember ?? currentClass;
 
   static void check(Program program) {
     program.accept(new VerifyingVisitor());
   }
 
   defaultTreeNode(TreeNode node) {
     visitChildren(node);
   }
 
-  problem(TreeNode node, String details, {TreeNode context}) {
-    context ??= this.context;
+  problem(TreeNode node, String details) {
     throw new VerificationError(context, node, details);
   }
 
   TreeNode enterParent(TreeNode node) {
     if (!identical(node.parent, currentParent)) {
       problem(
           node,
-          "Incorrect parent pointer on ${node.runtimeType}:"
-          " expected '${node.parent.runtimeType}',"
+          "Incorrect parent pointer: expected '${node.parent.runtimeType}',"
           " but found: '${currentParent.runtimeType}'.");
     }
     var oldParent = currentParent;
     currentParent = node;
     return oldParent;
   }
 
   void exitParent(TreeNode oldParent) {
     currentParent = oldParent;
   }
@@ skipping 39 matching lines @@
     variableStack.add(variable);
   }
 
   void undeclareVariable(VariableDeclaration variable) {
     variable.flags &= ~VariableDeclaration.FlagInScope;
   }
 
   void declareTypeParameters(List<TypeParameter> parameters) {
     for (int i = 0; i < parameters.length; ++i) {
       var parameter = parameters[i];
-      if (!typeParametersInScope.add(parameter)) {
+      if (!typeParameters.add(parameter)) {
         problem(parameter, "Type parameter '$parameter' redeclared.");
       }
     }
   }
 
   void undeclareTypeParameters(List<TypeParameter> parameters) {
-    typeParametersInScope.removeAll(parameters);
+    typeParameters.removeAll(parameters);
   }
 
   void checkVariableInScope(VariableDeclaration variable, TreeNode where) {
     if (variable.flags & VariableDeclaration.FlagInScope == 0) {
       problem(where, "Variable '$variable' used out of scope.");
     }
   }
 
   visitProgram(Program program) {
     try {
       for (var library in program.libraries) {
         for (var class_ in library.classes) {
           if (!classes.add(class_)) {
             problem(class_, "Class '$class_' declared more than once.");
           }
         }
-        for (var typedef_ in library.typedefs) {
-          if (!typedefs.add(typedef_)) {
-            problem(typedef_, "Typedef '$typedef_' declared more than once.");
-          }
-        }
         library.members.forEach(declareMember);
         for (var class_ in library.classes) {
           class_.members.forEach(declareMember);
         }
       }
       visitChildren(program);
     } finally {
       for (var library in program.libraries) {
         library.members.forEach(undeclareMember);
         for (var class_ in library.classes) {
           class_.members.forEach(undeclareMember);
         }
       }
       variableStack.forEach(undeclareVariable);
     }
   }
 
-  void checkTypedef(Typedef node) {
-    var state = typedefState[node];
-    if (state == TypedefState.Done) return;
-    if (state == TypedefState.BeingChecked) {
-      problem(node, "The typedef '$node' refers to itself", context: node);
-    }
-    assert(state == null);
-    typedefState[node] = TypedefState.BeingChecked;
-    var savedTypeParameters = typeParametersInScope;
-    typeParametersInScope = node.typeParameters.toSet();
-    var savedParent = currentParent;
-    currentParent = node;
-    // Visit children without checking the parent pointer on the typedef itself
-    // since this can be called from a context other than its true parent.
-    node.visitChildren(this);
-    currentParent = savedParent;
-    typeParametersInScope = savedTypeParameters;
-    typedefState[node] = TypedefState.Done;
-  }
-
-  visitTypedef(Typedef node) {
-    checkTypedef(node);
-    // Enter and exit the node to check the parent pointer on the typedef node.
-    exitParent(enterParent(node));
-  }
-
   visitField(Field node) {
     currentMember = node;
     var oldParent = enterParent(node);
     classTypeParametersAreInScope = !node.isStatic;
     node.initializer?.accept(this);
     classTypeParametersAreInScope = false;
     visitList(node.annotations, this);
     exitParent(oldParent);
-    node.type.accept(this);
     currentMember = null;
   }
 
   visitProcedure(Procedure node) {
     currentMember = node;
     var oldParent = enterParent(node);
     classTypeParametersAreInScope = !node.isStatic;
     node.function.accept(this);
     classTypeParametersAreInScope = false;
     visitList(node.annotations, this);
@@ skipping 288 matching lines @@
 
   @override
   visitClassReference(Class node) {
     if (!classes.contains(node)) {
       problem(
           node, "Dangling reference to '$node', parent is: '${node.parent}'.");
     }
   }
 
   @override
-  visitTypedefReference(Typedef node) {
-    if (!typedefs.contains(node)) {
-      problem(
-          node, "Dangling reference to '$node', parent is: '${node.parent}'");
-    }
-  }
-
-  @override
   visitTypeParameterType(TypeParameterType node) {
     var parameter = node.parameter;
-    if (!typeParametersInScope.contains(parameter)) {
+    if (!typeParameters.contains(parameter)) {
       problem(
           currentParent,
           "Type parameter '$parameter' referenced out of"
           " scope, parent is: '${parameter.parent}'.");
     }
     if (parameter.parent is Class && !classTypeParametersAreInScope) {
       problem(
           currentParent,
           "Type parameter '$parameter' referenced from"
           " static context, parent is '${parameter.parent}'.");
     }
   }
 
   @override
   visitInterfaceType(InterfaceType node) {
     node.visitChildren(this);
     if (node.typeArguments.length != node.classNode.typeParameters.length) {
       problem(
           currentParent,
           "Type $node provides ${node.typeArguments.length}"
           " type arguments but the class declares"
           " ${node.classNode.typeParameters.length} parameters.");
     }
   }
-
-  @override
-  visitTypedefType(TypedefType node) {
-    checkTypedef(node.typedefNode);
-    node.visitChildren(this);
-    if (node.typeArguments.length != node.typedefNode.typeParameters.length) {
-      problem(
-          currentParent,
-          "The typedef type $node provides ${node.typeArguments.length}"
-          " type arguments but the typedef declares"
-          " ${node.typedefNode.typeParameters.length} parameters.");
-    }
-  }
 }
 
 class CheckParentPointers extends Visitor {
   static void check(TreeNode node) {
     node.accept(new CheckParentPointers(node.parent));
   }
 
   TreeNode parent;
 
   CheckParentPointers([this.parent]);
@@ skipping 10 matching lines @@
     var oldParent = parent;
     parent = node;
     node.visitChildren(this);
     parent = oldParent;
   }
 }
 
 void checkInitializers(Constructor constructor) {
   // TODO(ahe): I'll add more here in other CLs.
 }