Use types.visit in test/syntax.js instead of Visitor.

benjamn · benjamn · commit b98bb8d1dbef · 2014-11-03T15:35:51.000-05:00
diff --git a/lib/printer.js b/lib/printer.js
@@ -924,6 +924,9 @@ function genericPrintNoParens(path, options, print) {
             parts.push(";");
         return concat(parts);
 
+    case "ClassProperty":
+        return concat([print(path.get("id")), ";"]);
+
     case "ClassDeclaration":
     case "ClassExpression":
         var parts = ["class"];
@@ -938,6 +941,20 @@ function genericPrintNoParens(path, options, print) {
 
         return concat(parts);
 
+    // These types are unprintable because they serve as abstract
+    // supertypes for other (printable) types.
+    case "Node":
+    case "SourceLocation":
+    case "Position":
+    case "Statement":
+    case "Function":
+    case "Pattern":
+    case "Expression":
+    case "Declaration":
+    case "Specifier":
+    case "NamedSpecifier":
+        throw new Error("unprintable type: " + JSON.stringify(n.type));
+
     // Unhandled types below. If encountered, nodes of these types should
     // be either left alone or desugared into AST types that are fully
     // supported by the pretty-printer.
@@ -955,6 +972,26 @@ function genericPrintNoParens(path, options, print) {
     case "GraphExpression": // TODO
     case "GraphIndexExpression": // TODO
     case "TypeAnnotation": // TODO
+    // XML types that nobody cares about or needs to print.
+    case "XMLDefaultDeclaration":
+    case "XMLAnyName":
+    case "XMLQualifiedIdentifier":
+    case "XMLFunctionQualifiedIdentifier":
+    case "XMLAttributeSelector":
+    case "XMLFilterExpression":
+    case "XML":
+    case "XMLElement":
+    case "XMLList":
+    case "XMLEscape":
+    case "XMLText":
+    case "XMLStartTag":
+    case "XMLEndTag":
+    case "XMLPointTag":
+    case "XMLName":
+    case "XMLAttribute":
+    case "XMLCdata":
+    case "XMLComment":
+    case "XMLProcessingInstruction":
     default:
         debugger;
         throw new Error("unknown type: " + JSON.stringify(n.type));
diff --git a/test/syntax.js b/test/syntax.js
@@ -3,7 +3,6 @@ var fs = require("fs");
 var path = require("path");
 var types = require("../lib/types");
 var parse = require("../lib/parser").parse;
-var Visitor = require("../lib/visitor").Visitor;
 
 describe("syntax", function() {
     // Make sure we handle all possible node types in Syntax, and no additional
@@ -17,49 +16,39 @@ describe("syntax", function() {
             var ast = parse(data);
             assert.ok(ast);
 
-            var types = {};
-            new GenericPrintVisitor(types).visit(ast);
+            var typeNames = {};
+            types.visit(ast, {
+                visitFunctionDeclaration: function(path) {
+                    var decl = path.node;
+                    if (types.namedTypes.Identifier.check(decl.id) &&
+                        decl.id.name === "genericPrintNoParens") {
+                        this.traverse(path, {
+                            visitSwitchCase: function(path) {
+                                var test = path.node.test;
+                                if (test &&
+                                    test.type === "Literal" &&
+                                    typeof test.value === "string") {
+                                    var name = test.value;
+                                    typeNames[name] = name;
+                                }
+                                return false;
+                            }
+                        });
+                    } else {
+                        this.traverse(path);
+                    }
+                }
+            });
 
             for (var name in types.namedTypes) {
                 if (types.namedTypes.hasOwnProperty(name)) {
-                    assert.ok(types.hasOwnProperty(name), "unhandled type: " + name);
-                    assert.strictEqual(name, types[name]);
-                    delete types[name];
+                    assert.ok(typeNames.hasOwnProperty(name), "unhandled type: " + name);
+                    assert.strictEqual(name, typeNames[name]);
+                    delete typeNames[name];
                 }
             }
 
             done();
         });
     });
-
-    var GenericPrintVisitor = Visitor.extend({
-        init: function(types) {
-            this.types = types;
-        },
-
-        visitFunctionDeclaration: function(decl) {
-            if (types.namedTypes.Identifier.check(decl.id) &&
-                decl.id.name === "genericPrintNoParens")
-            {
-                new CaseVisitor(this.types).visit(decl);
-            }
-        }
-    })
-
-    var CaseVisitor = Visitor.extend({
-        init: function(types) {
-            this.types = types;
-        },
-
-        visitSwitchCase: function(expr) {
-            var test = expr.test;
-            if (test &&
-                test.type === "Literal" &&
-                typeof test.value === "string")
-            {
-                var name = test.value;
-                this.types[name] = name;
-            }
-        }
-    });
 });
