Remove SyntaxNode.ts file

Lots of cleanup of the syntax generator.

Sort definitions.

Remove unused class.

src/services/syntax/SyntaxGenerator.js

@@ -883,7 +883,6 @@ var TypeScript;
         SyntaxFacts.isType = isType;
     })(SyntaxFacts = TypeScript.SyntaxFacts || (TypeScript.SyntaxFacts = {}));
 })(TypeScript || (TypeScript = {}));
-var argumentChecks = false;
 var forPrettyPrinter = false;
 var interfaces = {
     IMemberDeclarationSyntax: 'IClassElementSyntax',
@@ -1873,22 +1872,15 @@ var definitions = [
 ];
 function firstKind(definition) {
     var kindName = getNameWithoutSuffix(definition);
-    var kind = TypeScript.SyntaxKind[kindName];
-    return kind;
+    return TypeScript.SyntaxKind[kindName];
 }
-var sortedDefinitions = definitions.sort(function (d1, d2) { return firstKind(d1) - firstKind(d2); });
+definitions.sort(function (d1, d2) { return firstKind(d1) - firstKind(d2); });
 function getStringWithoutSuffix(definition) {
     if (TypeScript.StringUtilities.endsWith(definition, "Syntax")) {
         return definition.substring(0, definition.length - "Syntax".length);
     }
     return definition;
 }
-function getStringWithoutPrefix(definition) {
-    if (definition.charAt(0) == "I" && definition.charAt(1).toUpperCase() == definition.charAt(1)) {
-        return definition.substring(1);
-    }
-    return definition;
-}
 function getNameWithoutSuffix(definition) {
     return getStringWithoutSuffix(definition.name);
 }
@@ -1906,9 +1898,6 @@ function getType(child) {
         return child.type;
     }
 }
-function pascalCase(value) {
-    return value.substr(0, 1).toUpperCase() + value.substr(1);
-}
 function camelCase(value) {
     return value.substr(0, 1).toLowerCase() + value.substr(1);
 }
@@ -1918,339 +1907,6 @@ function getSafeName(child) {
     }
     return child.name;
 }
-function getPropertyAccess(child, instance) {
-    if (instance === void 0) { instance = "this"; }
-    if (child.type === "SyntaxKind") {
-        return instance + "._kind";
-    }
-    return instance + "." + child.name;
-}
-function generateProperties(definition) {
-    var result = "";
-    if (definition.name === "SourceUnitSyntax") {
-        result += "        public syntaxTree: SyntaxTree = undefined;\r\n";
-    }
-    var newLine = false;
-    for (var i = 0; i < definition.children.length; i++) {
-        var child = definition.children[i];
-        if (getType(child) === "SyntaxKind") {
-            result += "        private _" + child.name + ": " + getType(child) + ";\r\n";
-            newLine = true;
-        }
-        else if (child.name === "arguments") {
-            result += "    public " + child.name + ": " + getType(child) + ";\r\n";
-        }
-    }
-    if (newLine) {
-        result += "\r\n";
-    }
-    return result;
-}
-function generateNullChecks(definition) {
-    var result = "";
-    for (var i = 0; i < definition.children.length; i++) {
-        var child = definition.children[i];
-        if (!child.isOptional && !child.isToken) {
-            result += "        if (!" + child.name + ") { throw Errors.argumentNull('" + child.name + "'); }\r\n";
-        }
-    }
-    return result;
-}
-function generateIfKindCheck(child, tokenKinds, indent) {
-    var result = "";
-    result += indent + "        if (";
-    for (var j = 0; j < tokenKinds.length; j++) {
-        if (j > 0) {
-            result += " && ";
-        }
-        var tokenKind = tokenKinds[j];
-        if (tokenKind === "IdentifierName") {
-            result += "!SyntaxFacts.isIdentifierName(" + child.name + ".tokenKind)";
-        }
-        else {
-            result += child.name + ".tokenKind !== SyntaxKind." + tokenKind;
-        }
-    }
-    result += ") { throw Errors.argument('" + child.name + "'); }\r\n";
-    return result;
-}
-function generateSwitchCase(tokenKind, indent) {
-    return indent + "            case SyntaxKind." + tokenKind + ":\r\n";
-}
-function generateBreakStatement(indent) {
-    return indent + "                break;\r\n";
-}
-function generateSwitchCases(tokenKinds, indent) {
-    var result = "";
-    for (var j = 0; j < tokenKinds.length; j++) {
-        var tokenKind = tokenKinds[j];
-        result += generateSwitchCase(tokenKind, indent);
-    }
-    if (tokenKinds.length > 0) {
-        result += generateBreakStatement(indent);
-    }
-    return result;
-}
-function generateDefaultCase(child, indent) {
-    var result = "";
-    result += indent + "            default:\r\n";
-    result += indent + "                throw Errors.argument('" + child.name + "');\r\n";
-    return result;
-}
-function generateSwitchKindCheck(child, tokenKinds, indent) {
-    if (tokenKinds.length === 0) {
-        return "";
-    }
-    var result = "";
-    var identifierName = TypeScript.ArrayUtilities.where(tokenKinds, function (v) { return v.indexOf("IdentifierName") >= 0; });
-    var notIdentifierName = TypeScript.ArrayUtilities.where(tokenKinds, function (v) { return v.indexOf("IdentifierName") < 0; });
-    if (identifierName.length > 0) {
-        result += indent + "        if (!SyntaxFacts.isIdentifierName(" + child.name + ".tokenKind)) {\r\n";
-        if (notIdentifierName.length === 0) {
-            result += indent + "            throw Errors.argument('" + child.name + "');\r\n";
-            result += indent + "        }\r\n";
-            return result;
-        }
-        indent += "    ";
-    }
-    if (notIdentifierName.length <= 2) {
-        result += generateIfKindCheck(child, notIdentifierName, indent);
-    }
-    else if (notIdentifierName.length > 2) {
-        result += indent + "        switch (" + child.name + ".tokenKind) {\r\n";
-        result += generateSwitchCases(notIdentifierName, indent);
-        result += generateDefaultCase(child, indent);
-        result += indent + "        }\r\n";
-    }
-    if (identifierName.length > 0) {
-        result += indent + "    }\r\n";
-    }
-    return result;
-}
-function tokenKinds(child) {
-    return child.tokenKinds ? child.tokenKinds : [pascalCase(child.name)];
-}
-function generateKindCheck(child) {
-    var indent = "";
-    var result = "";
-    if (child.isOptional) {
-        indent = "    ";
-        result += "        if (" + child.name + ") {\r\n";
-    }
-    var kinds = tokenKinds(child);
-    if (kinds.length <= 2) {
-        result += generateIfKindCheck(child, kinds, indent);
-    }
-    else {
-        result += generateSwitchKindCheck(child, kinds, indent);
-    }
-    if (child.isOptional) {
-        result += "        }\r\n";
-    }
-    return result;
-}
-function generateKindChecks(definition) {
-    var result = "";
-    for (var i = 0; i < definition.children.length; i++) {
-        var child = definition.children[i];
-        if (child.isToken) {
-            result += generateKindCheck(child);
-        }
-    }
-    return result;
-}
-function generateArgumentChecks(definition) {
-    var result = "";
-    if (argumentChecks) {
-        result += generateNullChecks(definition);
-        result += generateKindChecks(definition);
-        if (definition.children.length > 0) {
-            result += "\r\n";
-        }
-    }
-    return result;
-}
-function generateConstructor(definition) {
-    var i;
-    var child;
-    var base = baseType(definition);
-    var result = "";
-    result += "        constructor(";
-    var children = definition.children;
-    var kindChild = undefined;
-    for (i = 0; i < children.length; i++) {
-        child = children[i];
-        if (getType(child) === "SyntaxKind") {
-            kindChild = child;
-        }
-        if (getType(child) !== "SyntaxKind" && child.name !== "arguments") {
-            result += "public ";
-        }
-        result += getSafeName(child) + ": " + getType(child);
-        result += ",\r\n                    ";
-    }
-    result += "data: number) {\r\n";
-    if (kindChild) {
-        result += "            super(kind, data); \r\n";
-    }
-    else {
-        result += "            super(SyntaxKind." + getNameWithoutSuffix(definition) + ", data); \r\n";
-    }
-    if (definition.children.length > 0) {
-        result += "\r\n";
-    }
-    result += generateArgumentChecks(definition);
-    for (i = 0; i < definition.children.length; i++) {
-        child = definition.children[i];
-        if (child.type === "SyntaxKind" || child.name === "arguments") {
-            result += "            " + getPropertyAccess(child) + " = " + getSafeName(child) + ";\r\n";
-        }
-    }
-    for (i = 0; i < definition.children.length; i++) {
-        child = definition.children[i];
-        if (child.type !== "SyntaxKind") {
-            if (child.isOptional) {
-                result += "            " + getSafeName(child) + " && (" + getSafeName(child) + ".parent = this);\r\n";
-            }
-            else {
-                result += "            " + getSafeName(child) + ".parent = this;\r\n";
-            }
-        }
-    }
-    result += "        }\r\n";
-    return result;
-}
-function isOptional(child) {
-    if (child.isOptional) {
-        return true;
-    }
-    if (child.isList && !child.requiresAtLeastOneItem) {
-        return true;
-    }
-    if (child.isSeparatedList && !child.requiresAtLeastOneItem) {
-        return true;
-    }
-    return false;
-}
-function generateFactory1Method(definition) {
-    return "";
-    var mandatoryChildren = TypeScript.ArrayUtilities.where(definition.children, function (c) { return !isOptional(c); });
-    if (mandatoryChildren.length === definition.children.length) {
-        return "";
-    }
-    var result = "\r\n        public static create(";
-    var i;
-    var child;
-    for (i = 0; i < mandatoryChildren.length; i++) {
-        child = mandatoryChildren[i];
-        result += child.name + ": " + getType(child);
-        if (i < mandatoryChildren.length - 1) {
-            result += ",\r\n                             ";
-        }
-    }
-    result += "): " + definition.name + " {\r\n";
-    result += "            return new " + definition.name + "(";
-    for (i = 0; i < definition.children.length; i++) {
-        child = definition.children[i];
-        if (!isOptional(child)) {
-            result += child.name;
-        }
-        else if (child.isList) {
-            result += "Syntax.emptyList<" + child.elementType + ">()";
-        }
-        else if (child.isSeparatedList) {
-            result += "Syntax.emptySeparatedList<" + child.elementType + ">()";
-        }
-        else {
-            result += "undefined";
-        }
-        result += ", ";
-    }
-    result += "/*data:*/ 0);\r\n";
-    result += "        }\r\n";
-    return result;
-}
-function isKeywordOrPunctuation(kind) {
-    if (TypeScript.StringUtilities.endsWith(kind, "Keyword")) {
-        return true;
-    }
-    if (TypeScript.StringUtilities.endsWith(kind, "Token") && kind !== "IdentifierName" && kind !== "EndOfFileToken") {
-        return true;
-    }
-    return false;
-}
-function isDefaultConstructable(definition) {
-    if (!definition) {
-        return false;
-    }
-    for (var i = 0; i < definition.children.length; i++) {
-        if (isMandatory(definition.children[i])) {
-            return false;
-        }
-    }
-    return true;
-}
-function isMandatory(child) {
-    if (isOptional(child)) {
-        return false;
-    }
-    if (child.type === "SyntaxKind" || child.isList || child.isSeparatedList) {
-        return true;
-    }
-    if (child.isToken) {
-        var kinds = tokenKinds(child);
-        var isFixed = kinds.length === 1 && isKeywordOrPunctuation(kinds[0]);
-        return !isFixed;
-    }
-    return !isDefaultConstructable(memberDefinitionType(child));
-}
-function generateFactory2Method(definition) {
-    return "";
-    var mandatoryChildren = TypeScript.ArrayUtilities.where(definition.children, isMandatory);
-    if (mandatoryChildren.length === definition.children.length) {
-        return "";
-    }
-    var i;
-    var child;
-    var result = "\r\n        public static create1(";
-    for (i = 0; i < mandatoryChildren.length; i++) {
-        child = mandatoryChildren[i];
-        result += child.name + ": " + getType(child);
-        if (i < mandatoryChildren.length - 1) {
-            result += ",\r\n                              ";
-        }
-    }
-    result += "): " + definition.name + " {\r\n";
-    result += "            return new " + definition.name + "(";
-    for (i = 0; i < definition.children.length; i++) {
-        child = definition.children[i];
-        if (isMandatory(child)) {
-            result += child.name;
-        }
-        else if (child.isList) {
-            result += "Syntax.emptyList<" + child.elementType + ">()";
-        }
-        else if (child.isSeparatedList) {
-            result += "Syntax.emptySeparatedList<" + child.elementType + ">()";
-        }
-        else if (isOptional(child)) {
-            result += "undefined";
-        }
-        else if (child.isToken) {
-            result += "Syntax.token(SyntaxKind." + tokenKinds(child)[0] + ")";
-        }
-        else {
-            result += child.type + ".create1()";
-        }
-        result += ", ";
-    }
-    result += "/*data:*/ 0);\r\n";
-    result += "        }\r\n";
-    return result;
-}
-function generateFactoryMethod(definition) {
-    return generateFactory1Method(definition) + generateFactory2Method(definition);
-}
 function generateBrands(definition, accessibility) {
     var properties = "";
     var types = [];
@@ -2288,300 +1944,6 @@ function generateBrands(definition, accessibility) {
     }
     return properties;
 }
-function generateAcceptMethod(definition) {
-    var result = "";
-    result += "\r\n";
-    result += "        public accept(visitor: ISyntaxVisitor): SyntaxKind {\r\n";
-    result += "            return visitor.visit" + getNameWithoutSuffix(definition) + "(this);\r\n";
-    result += "        }\r\n";
-    return result;
-}
-function generateKindMethod(definition) {
-    var result = "";
-    result += "\r\n";
-    result += "        public kind(): SyntaxKind {\r\n";
-    result += "            return SyntaxKind." + getNameWithoutSuffix(definition) + ";\r\n";
-    result += "        }\r\n";
-    return result;
-}
-function generateSlotMethods(definition) {
-    var result = "";
-    result += "\r\n";
-    var slotCount = definition.children.length;
-    result += "        public childCount(): number {\r\n";
-    result += "            return " + slotCount + ";\r\n";
-    result += "        }\r\n\r\n";
-    result += "        public childAt(slot: number): ISyntaxElement {\r\n";
-    if (slotCount === 0) {
-        result += "            throw Errors.invalidOperation();\r\n";
-    }
-    else {
-        result += "            switch (slot) {\r\n";
-        var index = 0;
-        for (var i = 0; i < definition.children.length; i++) {
-            var child = definition.children[i];
-            if (child.type === "SyntaxKind") {
-                continue;
-            }
-            result += "                case " + index + ": return this." + child.name + ";\r\n";
-            index++;
-        }
-        result += "                default: throw Errors.invalidOperation();\r\n";
-        result += "            }\r\n";
-    }
-    result += "        }\r\n";
-    return result;
-}
-function generateFirstTokenMethod(definition) {
-    var result = "";
-    result += "\r\n";
-    result += "    public firstToken(): ISyntaxToken {\r\n";
-    result += "        var token: ISyntaxToken = undefined;\r\n";
-    for (var i = 0; i < definition.children.length; i++) {
-        var child = definition.children[i];
-        if (getType(child) === "SyntaxKind") {
-            continue;
-        }
-        if (child.name === "endOfFileToken") {
-            continue;
-        }
-        result += "        if (";
-        if (child.isOptional) {
-            result += getPropertyAccess(child) + " && ";
-        }
-        if (child.isToken) {
-            result += getPropertyAccess(child) + ".width() > 0";
-            result += ") { return " + getPropertyAccess(child) + "; }\r\n";
-        }
-        else {
-            result += "(token = " + getPropertyAccess(child) + ".firstToken())";
-            result += ") { return token; }\r\n";
-        }
-    }
-    if (definition.name === "SourceUnitSyntax") {
-        result += "        return this._endOfFileToken;\r\n";
-    }
-    else {
-        result += "        return undefined;\r\n";
-    }
-    result += "    }\r\n";
-    result += "    }\r\n";
-    return result;
-}
-function generateLastTokenMethod(definition) {
-    var result = "";
-    result += "\r\n";
-    result += "    public lastToken(): ISyntaxToken {\r\n";
-    if (definition.name === "SourceUnitSyntax") {
-        result += "        return this._endOfFileToken;\r\n";
-    }
-    else {
-        result += "        var token: ISyntaxToken = undefined;\r\n";
-        for (var i = definition.children.length - 1; i >= 0; i--) {
-            var child = definition.children[i];
-            if (getType(child) === "SyntaxKind") {
-                continue;
-            }
-            if (child.name === "endOfFileToken") {
-                continue;
-            }
-            result += "        if (";
-            if (child.isOptional) {
-                result += getPropertyAccess(child) + " && ";
-            }
-            if (child.isToken) {
-                result += getPropertyAccess(child) + ".width() > 0";
-                result += ") { return " + getPropertyAccess(child) + "; }\r\n";
-            }
-            else {
-                result += "(token = " + getPropertyAccess(child) + ".lastToken())";
-                result += ") { return token; }\r\n";
-            }
-        }
-        result += "        return undefined;\r\n";
-    }
-    result += "    }\r\n";
-    return result;
-}
-function baseType(definition) {
-    return TypeScript.ArrayUtilities.firstOrDefault(definitions, function (d) { return d.name === definition.baseType; });
-}
-function memberDefinitionType(child) {
-    return TypeScript.ArrayUtilities.firstOrDefault(definitions, function (d) { return d.name === child.type; });
-}
-function derivesFrom(def1, def2) {
-    var current = def1;
-    while (current) {
-        var base = baseType(current);
-        if (base === def2) {
-            return true;
-        }
-        current = base;
-    }
-    return false;
-}
-function contains(definition, child) {
-    return TypeScript.ArrayUtilities.any(definition.children, function (c) { return c.name === child.name && c.isList === child.isList && c.isSeparatedList === child.isSeparatedList && c.isToken === child.isToken && c.type === child.type; });
-}
-function generateAccessors(definition) {
-    var result = "";
-    return result;
-}
-function generateWithMethod(definition, child) {
-    return "";
-    var result = "";
-    result += "\r\n";
-    result += "        public with" + pascalCase(child.name) + "(" + getSafeName(child) + ": " + getType(child) + "): " + definition.name + " {\r\n";
-    result += "            return this.update(";
-    for (var i = 0; i < definition.children.length; i++) {
-        if (i > 0) {
-            result += ", ";
-        }
-        if (definition.children[i] === child) {
-            result += getSafeName(child);
-        }
-        else {
-            result += getPropertyAccess(definition.children[i]);
-        }
-    }
-    result += ");\r\n";
-    result += "        }\r\n";
-    if (child.isList || child.isSeparatedList) {
-        if (TypeScript.StringUtilities.endsWith(child.name, "s")) {
-            var pascalName = pascalCase(child.name);
-            pascalName = pascalName.substring(0, pascalName.length - 1);
-            var argName = getSafeName(child);
-            argName = argName.substring(0, argName.length - 1);
-            result += "\r\n";
-            result += "        public with" + pascalName + "(" + argName + ": " + child.elementType + "): " + definition.name + " {\r\n";
-            result += "            return this.with" + pascalCase(child.name) + "(";
-            if (child.isList) {
-                result += "Syntax.list<" + child.elementType + ">([" + argName + "])";
-            }
-            else {
-                result += "Syntax.separatedList<" + child.elementType + ">([" + argName + "])";
-            }
-            result += ");\r\n";
-            result += "        }\r\n";
-        }
-    }
-    return result;
-}
-function generateWithMethods(definition) {
-    var result = "";
-    return "";
-    for (var i = 0; i < definition.children.length; i++) {
-        var child = definition.children[i];
-        result += generateWithMethod(definition, child);
-    }
-    return result;
-}
-function generateTriviaMethods(definition) {
-    return "";
-    var result = "\r\n";
-    result += "        public withLeadingTrivia(trivia: ISyntaxTriviaList): " + definition.name + " {\r\n";
-    result += "            return <" + definition.name + ">super.withLeadingTrivia(trivia);\r\n";
-    result += "        }\r\n\r\n";
-    result += "        public withTrailingTrivia(trivia: ISyntaxTriviaList): " + definition.name + " {\r\n";
-    result += "            return <" + definition.name + ">super.withTrailingTrivia(trivia);\r\n";
-    result += "        }\r\n";
-    return result;
-}
-function generateUpdateMethod(definition) {
-    var result = "";
-    result += "\r\n";
-    result += "        public update(";
-    var i;
-    var child;
-    for (i = 0; i < definition.children.length; i++) {
-        child = definition.children[i];
-        result += getSafeName(child) + ": " + getType(child);
-        if (i < definition.children.length - 1) {
-            result += ",\r\n                      ";
-        }
-    }
-    result += "): " + definition.name + " {\r\n";
-    if (definition.children.length === 0) {
-        result += "            return this;\r\n";
-    }
-    else {
-        result += "            if (";
-        for (i = 0; i < definition.children.length; i++) {
-            child = definition.children[i];
-            if (i !== 0) {
-                result += " && ";
-            }
-            result += getPropertyAccess(child) + " === " + getSafeName(child);
-        }
-        result += ") {\r\n";
-        result += "                return this;\r\n";
-        result += "            }\r\n\r\n";
-        result += "            return new " + definition.name + "(";
-        for (i = 0; i < definition.children.length; i++) {
-            child = definition.children[i];
-            result += getSafeName(child);
-            result += ", ";
-        }
-        result += "this.parsedInStrictMode() ? SyntaxConstants.NodeParsedInStrictModeMask : 0);\r\n";
-    }
-    result += "        }\r\n";
-    return result;
-}
-function generateNode(definition, abstract) {
-    var result = "    export class " + definition.name + " implements ISyntaxNode";
-    if (definition.interfaces) {
-        result += ", ";
-        result += definition.interfaces.join(", ");
-    }
-    result += " {\r\n";
-    result += "        public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement;\r\n";
-    if (definition.name === "SourceUnitSyntax") {
-        result += "        public syntaxTree: SyntaxTree = undefined;\r\n";
-    }
-    for (var i = 0; i < definition.children.length; i++) {
-        var child = definition.children[i];
-        result += "        public " + child.name + ": " + getType(child) + ";\r\n";
-    }
-    result += generateBrands(definition, true);
-    result += "        constructor(data: number";
-    for (var i = 0; i < definition.children.length; i++) {
-        var child = definition.children[i];
-        result += ", " + getSafeName(child) + ": " + getType(child);
-    }
-    result += ") {\r\n";
-    result += "            if (data) { this.__data = data; }\r\n";
-    if (definition.name === "SourceUnitSyntax") {
-        result += "            this.parent = undefined,\r\n";
-    }
-    if (definition.children) {
-        for (var i = 0; i < definition.children.length; i++) {
-            var child = definition.children[i];
-            if (child.excludeFromAST && abstract) {
-                continue;
-            }
-            result += "            this." + child.name + " = " + getSafeName(child) + ",\r\n";
-        }
-    }
-    if (definition.children.length > 0) {
-        for (var i = 0; i < definition.children.length; i++) {
-            var child = definition.children[i];
-            if (i) {
-                result += ",\r\n";
-            }
-            if (child.isOptional) {
-                result += "            " + getSafeName(child) + " && (" + getSafeName(child) + ".parent = this)";
-            }
-            else {
-                result += "            " + getSafeName(child) + ".parent = this";
-            }
-        }
-        result += ";\r\n";
-    }
-    result += "        }\r\n";
-    result += generateKindMethod(definition);
-    result += "    }";
-    return result;
-}
 function generateConstructorFunction(definition) {
     var result = "    export var " + definition.name + ": " + getNameWithoutSuffix(definition) + "Constructor = <any>function(data: number";
     for (var i = 0; i < definition.children.length; i++) {
@@ -2623,23 +1985,6 @@ function generateConstructorFunction(definition) {
     result += "    " + definition.name + ".prototype.kind = function() { return SyntaxKind." + getNameWithoutSuffix(definition) + "; }\r\n";
     return result;
 }
-function syntaxKindName(kind) {
-    for (var name in TypeScript.SyntaxKind) {
-        if (TypeScript.SyntaxKind[name] === kind) {
-            return name;
-        }
-    }
-    throw new Error();
-}
-function getDefinitionForKind(kind) {
-    var kindName = syntaxKindName(kind);
-    return TypeScript.ArrayUtilities.firstOrDefault(definitions, function (d) {
-        if (getNameWithoutSuffix(d) === kindName) {
-            return true;
-        }
-        return false;
-    });
-}
 function generateSyntaxInterfaces() {
     var result = "///<reference path='references.ts' />\r\n\r\n";
     result += "module TypeScript {\r\n";
@@ -2680,7 +2025,7 @@ function generateSyntaxInterface(definition) {
     result += " }\r\n";
     return result;
 }
-function generateNodes(abstract) {
+function generateNodes() {
     var result = "///<reference path='references.ts' />\r\n\r\n";
     result += "module TypeScript";
     result += " {\r\n";
@@ -2697,54 +2042,6 @@ function generateNodes(abstract) {
 function isInterface(name) {
     return name.substr(0, 1) === "I" && name.substr(1, 1).toUpperCase() === name.substr(1, 1);
 }
-function isNodeOrToken(child) {
-    return child.type && isInterface(child.type);
-}
-function generateRewriter() {
-    var result = "///<reference path='references.ts' />\r\n\r\n";
-    result += "module TypeScript {\r\n" + "    export class SyntaxRewriter implements ISyntaxVisitor {\r\n" + "        public visitToken(token: ISyntaxToken): ISyntaxToken {\r\n" + "            return token;\r\n" + "        }\r\n" + "\r\n" + "        public visitNode(node: ISyntaxNode): ISyntaxNode {\r\n" + "            return visitNodeOrToken(this, node);\r\n" + "        }\r\n" + "\r\n" + "        public visitNodeOrToken(node: ISyntaxNodeOrToken): ISyntaxNodeOrToken {\r\n" + "            return isToken(node) ? <ISyntaxNodeOrToken>this.visitToken(<ISyntaxToken>node) : this.visitNode(<ISyntaxNode>node);\r\n" + "        }\r\n" + "\r\n" + "        public visitList<T extends ISyntaxNodeOrToken[]>(list: T): T {\r\n" + "            var newItems: T = undefined;\r\n" + "\r\n" + "            for (var i = 0, n = list.length; i < n; i++) {\r\n" + "                var item = list[i];\r\n" + "                var newItem = this.visitNodeOrToken(item);\r\n" + "\r\n" + "                if (item !== newItem && !newItems) {\r\n" + "                    newItems = [];\r\n" + "                    for (var j = 0; j < i; j++) {\r\n" + "                        newItems.push(list[j]);\r\n" + "                    }\r\n" + "                }\r\n" + "\r\n" + "                if (newItems) {\r\n" + "                    newItems.push(newItem);\r\n" + "                }\r\n" + "            }\r\n" + "\r\n" + "            // Debug.assert(!newItems || newItems.length === childCount(list));\r\n" + "            return !newItems ? list : <T>Syntax.list(newItems);\r\n" + "        }\r\n" + "\r\n";
-    for (var i = 0; i < definitions.length; i++) {
-        var definition = definitions[i];
-        result += "\r\n";
-        result += "        public visit" + getNameWithoutSuffix(definition) + "(node: " + definition.name + "): any {\r\n";
-        if (definition.children.length === 0) {
-            result += "            return node;\r\n";
-            result += "        }\r\n";
-            continue;
-        }
-        result += "            return node.update(\r\n";
-        for (var j = 0; j < definition.children.length; j++) {
-            var child = definition.children[j];
-            result += "                ";
-            if (child.isOptional) {
-                result += "!node." + child.name + " ? undefined : ";
-            }
-            if (child.isToken) {
-                result += "this.visitToken(node." + child.name + ")";
-            }
-            else if (child.isList || child.isSeparatedList) {
-                result += "this.visitList(node." + child.name + ")";
-            }
-            else if (child.type === "SyntaxKind") {
-                result += "node.kind";
-            }
-            else if (isNodeOrToken(child)) {
-                result += "<" + child.type + ">this.visitNodeOrToken(node." + child.name + ")";
-            }
-            else {
-                result += "<" + child.type + ">this.visitNode(node." + child.name + ")";
-            }
-            if (j < definition.children.length - 1) {
-                result += ",\r\n";
-            }
-        }
-        result += ");\r\n";
-        result += "        }\r\n";
-    }
-    result += "    }";
-    result += "\r\n}";
-    return result;
-}
 function generateWalker() {
     var result = "";
     result += "///<reference path='references.ts' />\r\n" + "\r\n" + "module TypeScript {\r\n" + "    export class SyntaxWalker implements ISyntaxVisitor {\r\n" + "        public visitToken(token: ISyntaxToken): void {\r\n" + "        }\r\n" + "\r\n" + "        private visitOptionalToken(token: ISyntaxToken): void {\r\n" + "            if (token === undefined) {\r\n" + "                return;\r\n" + "            }\r\n" + "\r\n" + "            this.visitToken(token);\r\n" + "        }\r\n" + "\r\n" + "        public visitList(list: ISyntaxNodeOrToken[]): void {\r\n" + "            for (var i = 0, n = list.length; i < n; i++) {\r\n" + "                visitNodeOrToken(this, list[i]);\r\n" + "            }\r\n" + "        }\r\n";
@@ -2765,10 +2062,7 @@ function generateWalker() {
             else if (child.isList || child.isSeparatedList) {
                 result += "            this.visitList(node." + child.name + ");\r\n";
             }
-            else if (isNodeOrToken(child)) {
-                result += "            visitNodeOrToken(this, node." + child.name + ");\r\n";
-            }
-            else if (child.type === "ISyntaxToken") {
+            else if (child.isToken) {
                 if (child.isOptional) {
                     result += "            this.visitOptionalToken(node." + child.name + ");\r\n";
                 }
@@ -2776,7 +2070,7 @@ function generateWalker() {
                     result += "            this.visitToken(node." + child.name + ");\r\n";
                 }
             }
-            else if (child.type !== "SyntaxKind") {
+            else {
                 result += "            visitNodeOrToken(this, node." + child.name + ");\r\n";
             }
         }
@@ -2894,6 +2188,14 @@ function generateScannerUtilities() {
     result += "}";
     return result;
 }
+function syntaxKindName(kind) {
+    for (var name in TypeScript.SyntaxKind) {
+        if (TypeScript.SyntaxKind[name] === kind) {
+            return name;
+        }
+    }
+    throw new Error();
+}
 function generateVisitor() {
     var result = "";
     result += "///<reference path='references.ts' />\r\n\r\n";
@@ -2919,30 +2221,6 @@ function generateVisitor() {
     result += "\r\n}";
     return result;
 }
-function generateDefaultVisitor() {
-    var result = "";
-    result += "///<reference path='references.ts' />\r\n\r\n";
-    result += "module TypeScript {\r\n";
-    if (!forPrettyPrinter) {
-        result += "    export class SyntaxVisitor implements ISyntaxVisitor {\r\n";
-        result += "        public defaultVisit(node: ISyntaxNodeOrToken): any {\r\n";
-        result += "            return undefined;\r\n";
-        result += "        }\r\n";
-        result += "\r\n";
-        result += "        public visitToken(token: ISyntaxToken): any {\r\n";
-        result += "            return this.defaultVisit(token);\r\n";
-        result += "        }\r\n";
-        for (var i = 0; i < definitions.length; i++) {
-            var definition = definitions[i];
-            result += "\r\n        public visit" + getNameWithoutSuffix(definition) + "(node: " + definition.name + "): any {\r\n";
-            result += "            return this.defaultVisit(node);\r\n";
-            result += "        }\r\n";
-        }
-        result += "    }";
-    }
-    result += "\r\n}";
-    return result;
-}
 function generateServicesUtilities() {
     var result = "";
     result += "module TypeScript {\r\n";
@@ -2983,114 +2261,15 @@ function generateServicesUtilities() {
     result += "}";
     return result;
 }
-function generateIsTypeScriptSpecific() {
-    var result = "";
-    result += "module TypeScript {\r\n";
-    result += "    function isListTypeScriptSpecific(list: ISyntaxNodeOrToken[]): boolean {\r\n";
-    result += "        for (var i = 0, n = list.length; i < n; i++) {\r\n";
-    result += "            if (isTypeScriptSpecific(list[i])) {\r\n";
-    result += "                return true;\r\n";
-    result += "            }\r\n";
-    result += "        }\r\n\r\n";
-    result += "        return false;\r\n";
-    result += "    }\r\n\r\n";
-    result += "    export function isTypeScriptSpecific(element: ISyntaxElement): boolean {\r\n";
-    result += "        if (!element) { return false; }\r\n";
-    result += "        if (isToken(element)) { return false; }\r\n";
-    result += "        if (isList(element)) { return isListTypeScriptSpecific(<ISyntaxNodeOrToken[]>element); }\r\n";
-    result += "        switch (element.kind()) {\r\n";
-    for (var i = 0; i < definitions.length; i++) {
-        var definition = definitions[i];
-        if (!definition.isTypeScriptSpecific) {
-            continue;
-        }
-        result += "            case SyntaxKind." + getNameWithoutSuffix(definition) + ":\r\n";
-    }
-    result += "                return true;\r\n";
-    var triviallyFalseDefinitions = definitions.filter(function (d) { return d.children.filter(function (c) { return c.type !== "SyntaxKind" && !c.isToken; }).length === 0; });
-    for (var i = 0; i < triviallyFalseDefinitions.length; i++) {
-        var definition = triviallyFalseDefinitions[i];
-        if (definition.isTypeScriptSpecific) {
-            continue;
-        }
-        result += "            case SyntaxKind." + getNameWithoutSuffix(definition) + ":\r\n";
-    }
-    result += "                return false;\r\n";
-    for (var i = 0; i < definitions.length; i++) {
-        var definition = definitions[i];
-        if (definition.isTypeScriptSpecific) {
-            continue;
-        }
-        if (definition.children.filter(function (c) { return c.type !== "SyntaxKind" && !c.isToken; }).length === 0) {
-            continue;
-        }
-        result += "            case SyntaxKind." + getNameWithoutSuffix(definition) + ":";
-        result += "\r\n";
-        result += "                return is" + getNameWithoutSuffix(definition) + "TypeScriptSpecific(<" + definition.name + ">element);\r\n";
-    }
-    result += "        }\r\n";
-    result += "    }\r\n";
-    for (var i = 0; i < definitions.length; i++) {
-        var definition = definitions[i];
-        if (definition.isTypeScriptSpecific) {
-            continue;
-        }
-        var importantChildren = definition.children.filter(function (d) { return d.type !== "SyntaxKind" && !d.isToken; });
-        if (importantChildren.length > 0) {
-            result += generateIsTypeScriptSpecificMethod(definition);
-        }
-    }
-    result += "}";
-    return result;
-}
-function generateIsTypeScriptSpecificMethod(definition) {
-    var result = "\r\n    function is" + getNameWithoutSuffix(definition) + "TypeScriptSpecific(node: " + definition.name + "): boolean {\r\n";
-    result += "        return ";
-    var addedCheck = false;
-    for (var i = 0; i < definition.children.length; i++) {
-        var child = definition.children[i];
-        if (child.type === "SyntaxKind") {
-            continue;
-        }
-        if (child.isToken) {
-            continue;
-        }
-        if (addedCheck) {
-            result += " ||\r\n               ";
-        }
-        addedCheck = true;
-        if (child.isTypeScriptSpecific) {
-            if (child.isList || child.isSeparatedList) {
-                result += getPropertyAccess(child, "node") + ".length > 0";
-            }
-            else {
-                result += "!!" + getPropertyAccess(child, "node");
-            }
-        }
-        else {
-            result += "isTypeScriptSpecific(" + getPropertyAccess(child, "node") + ")";
-        }
-    }
-    if (!addedCheck) {
-        result += "false";
-    }
-    result += ";\r\n";
-    result += "    }\r\n";
-    return result;
-}
-var syntaxNodesConcrete = generateNodes(false);
+var syntaxNodesConcrete = generateNodes();
 var syntaxInterfaces = generateSyntaxInterfaces();
-var rewriter = generateRewriter();
 var walker = generateWalker();
 var scannerUtilities = generateScannerUtilities();
 var visitor = generateVisitor();
-var defaultVisitor = generateDefaultVisitor();
 var servicesUtilities = generateServicesUtilities();
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxNodes.concrete.generated.ts", syntaxNodesConcrete, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxInterfaces.generated.ts", syntaxInterfaces, false);
-sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxRewriter.generated.ts", rewriter, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxWalker.generated.ts", walker, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\scannerUtilities.generated.ts", scannerUtilities, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxVisitor.generated.ts", visitor, false);
-sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\defaultSyntaxVisitor.generated.ts", defaultVisitor, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxUtilities.generated.ts", servicesUtilities, false);

src/services/syntax/defaultSyntaxVisitor.generated.ts

@@ -1,377 +0,0 @@
-///<reference path='references.ts' />
-
-module TypeScript {
-    export class SyntaxVisitor implements ISyntaxVisitor {
-        public defaultVisit(node: ISyntaxNodeOrToken): any {
-            return undefined;
-        }
-
-        public visitToken(token: ISyntaxToken): any {
-            return this.defaultVisit(token);
-        }
-
-        public visitSourceUnit(node: SourceUnitSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitQualifiedName(node: QualifiedNameSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitObjectType(node: ObjectTypeSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitFunctionType(node: FunctionTypeSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitArrayType(node: ArrayTypeSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitConstructorType(node: ConstructorTypeSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitGenericType(node: GenericTypeSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTypeQuery(node: TypeQuerySyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTupleType(node: TupleTypeSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitUnionType(node: UnionTypeSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitParenthesizedType(node: ParenthesizedTypeSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitInterfaceDeclaration(node: InterfaceDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitFunctionDeclaration(node: FunctionDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitModuleDeclaration(node: ModuleDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitClassDeclaration(node: ClassDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitEnumDeclaration(node: EnumDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitImportDeclaration(node: ImportDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitExportAssignment(node: ExportAssignmentSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitMemberFunctionDeclaration(node: MemberFunctionDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitMemberVariableDeclaration(node: MemberVariableDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitConstructorDeclaration(node: ConstructorDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitIndexMemberDeclaration(node: IndexMemberDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitGetAccessor(node: GetAccessorSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitSetAccessor(node: SetAccessorSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitPropertySignature(node: PropertySignatureSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitCallSignature(node: CallSignatureSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitConstructSignature(node: ConstructSignatureSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitIndexSignature(node: IndexSignatureSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitMethodSignature(node: MethodSignatureSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitBlock(node: BlockSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitIfStatement(node: IfStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitVariableStatement(node: VariableStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitExpressionStatement(node: ExpressionStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitReturnStatement(node: ReturnStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitSwitchStatement(node: SwitchStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitBreakStatement(node: BreakStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitContinueStatement(node: ContinueStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitForStatement(node: ForStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitForInStatement(node: ForInStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitEmptyStatement(node: EmptyStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitThrowStatement(node: ThrowStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitWhileStatement(node: WhileStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTryStatement(node: TryStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitLabeledStatement(node: LabeledStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitDoStatement(node: DoStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitDebuggerStatement(node: DebuggerStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitWithStatement(node: WithStatementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitPrefixUnaryExpression(node: PrefixUnaryExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitDeleteExpression(node: DeleteExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTypeOfExpression(node: TypeOfExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitVoidExpression(node: VoidExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitConditionalExpression(node: ConditionalExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitBinaryExpression(node: BinaryExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitPostfixUnaryExpression(node: PostfixUnaryExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitMemberAccessExpression(node: MemberAccessExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitInvocationExpression(node: InvocationExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitArrayLiteralExpression(node: ArrayLiteralExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitObjectLiteralExpression(node: ObjectLiteralExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitObjectCreationExpression(node: ObjectCreationExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitParenthesizedExpression(node: ParenthesizedExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitParenthesizedArrowFunctionExpression(node: ParenthesizedArrowFunctionExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitSimpleArrowFunctionExpression(node: SimpleArrowFunctionExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitCastExpression(node: CastExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitElementAccessExpression(node: ElementAccessExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitFunctionExpression(node: FunctionExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitOmittedExpression(node: OmittedExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTemplateExpression(node: TemplateExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTemplateAccessExpression(node: TemplateAccessExpressionSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitVariableDeclaration(node: VariableDeclarationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitVariableDeclarator(node: VariableDeclaratorSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitArgumentList(node: ArgumentListSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitParameterList(node: ParameterListSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTypeArgumentList(node: TypeArgumentListSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTypeParameterList(node: TypeParameterListSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitHeritageClause(node: HeritageClauseSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitEqualsValueClause(node: EqualsValueClauseSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitCaseSwitchClause(node: CaseSwitchClauseSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitDefaultSwitchClause(node: DefaultSwitchClauseSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitElseClause(node: ElseClauseSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitCatchClause(node: CatchClauseSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitFinallyClause(node: FinallyClauseSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTemplateClause(node: TemplateClauseSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTypeParameter(node: TypeParameterSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitConstraint(node: ConstraintSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitSimplePropertyAssignment(node: SimplePropertyAssignmentSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitFunctionPropertyAssignment(node: FunctionPropertyAssignmentSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitParameter(node: ParameterSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitEnumElement(node: EnumElementSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitTypeAnnotation(node: TypeAnnotationSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitExternalModuleReference(node: ExternalModuleReferenceSyntax): any {
-            return this.defaultVisit(node);
-        }
-
-        public visitModuleNameModuleReference(node: ModuleNameModuleReferenceSyntax): any {
-            return this.defaultVisit(node);
-        }
-    }
-}

src/services/syntax/references.ts

@@ -17,7 +17,6 @@
 ///<reference path='syntaxElement.ts' />
 ///<reference path='syntaxFacts2.ts' />
 ///<reference path='syntaxList.ts' />
-///<reference path='syntaxNode.ts' />
 ///<reference path='syntaxNodeOrToken.ts' />
 
 // SyntaxDedenter depends on SyntaxRewriter

src/services/syntax/syntaxNode.ts

@@ -1,34 +0,0 @@
-///<reference path='references.ts' />
-
-module TypeScript {
-    /*
-    export class SyntaxNode implements ISyntaxNode {
-        // private __kind: SyntaxKind;
-        public __data: number;
-        public __cachedTokens: ISyntaxToken[];
-        public parent: ISyntaxElement;
-
-        constructor(data: number) {
-            if (data) {
-                this.__data = data;
-            }
-        }
-
-        public kind(): SyntaxKind {
-            throw Errors.abstract();
-        }
-
-        public childCount(): number {
-            throw Errors.abstract();
-        }
-
-        public childAt(index: number): ISyntaxElement {
-            throw Errors.abstract();
-        }
-
-        public accept(visitor: ISyntaxVisitor): any {
-            throw Errors.abstract();
-        }
-    }
-    */
-}