Strip more unused features.

lib/literal.ts

Index: lib/literal.ts
diff --git a/lib/literal.ts b/lib/literal.ts
deleted file mode 100644
index efe1b0b5455419c14cb32070e106cdcff6d9e661..0000000000000000000000000000000000000000
--- a/lib/literal.ts
+++ /dev/null
@@ -1,164 +0,0 @@
-import * as ts from 'typescript';
-import * as base from './base';
-import {Transpiler} from './main';
-import {FacadeConverter} from './facade_converter';
-
-export default class LiteralTranspiler extends base.TranspilerBase {
-  constructor(tr: Transpiler, private fc: FacadeConverter) { super(tr); }
-
-  visitNode(node: ts.Node): boolean {
-    switch (node.kind) {
-      // Literals.
-      case ts.SyntaxKind.NumericLiteral:
-        let nLit = <ts.LiteralExpression>node;
-        this.emit(nLit.getText());
-        break;
-      case ts.SyntaxKind.StringLiteral:
-        let sLit = <ts.LiteralExpression>node;
-        let text = JSON.stringify(sLit.text);
-        // Escape dollar sign since dart will interpolate in double quoted literal
-        text = text.replace(/\$/, '\\$');
-        this.emit(text);
-        break;
-      case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
-        this.emit(`'''${this.escapeTextForTemplateString(node)}'''`);
-        break;
-      case ts.SyntaxKind.TemplateMiddle:
-        this.emitNoSpace(this.escapeTextForTemplateString(node));
-        break;
-      case ts.SyntaxKind.TemplateExpression:
-        let tmpl = <ts.TemplateExpression>node;
-        if (tmpl.head) this.visit(tmpl.head);
-        if (tmpl.templateSpans) this.visitEach(tmpl.templateSpans);
-        break;
-      case ts.SyntaxKind.TemplateHead:
-        this.emit(`'''${this.escapeTextForTemplateString(node)}`);  // highlighting bug:'
-        break;
-      case ts.SyntaxKind.TemplateTail:
-        this.emitNoSpace(this.escapeTextForTemplateString(node));
-        this.emitNoSpace(`'''`);
-        break;
-      case ts.SyntaxKind.TemplateSpan:
-        let span = <ts.TemplateSpan>node;
-        if (span.expression) {
-          // Do not emit extra whitespace inside the string template
-          this.emitNoSpace('${');
-          this.visit(span.expression);
-          this.emitNoSpace('}');
-        }
-        if (span.literal) this.visit(span.literal);
-        break;
-      case ts.SyntaxKind.ArrayLiteralExpression:
-        if (this.shouldBeConst(node)) this.emit('const');
-        let ale = <ts.ArrayLiteralExpression>node;
-        this.handleReifiedArray(ale);
-        this.emit('[');
-        this.visitList(ale.elements);
-        this.emit(']');
-        break;
-      case ts.SyntaxKind.ObjectLiteralExpression:
-        if (this.shouldBeConst(node)) this.emit('const');
-        let ole = <ts.ObjectLiteralExpression>node;
-        this.handleReifiedMap(ole);
-        this.emit('{');
-        this.visitList(ole.properties);
-        this.emit('}');
-        break;
-      case ts.SyntaxKind.PropertyAssignment:
-        let propAssign = <ts.PropertyAssignment>node;
-        if (propAssign.name.kind === ts.SyntaxKind.Identifier) {
-          // Dart identifiers in Map literals need quoting.
-          this.emitNoSpace(' "');
-          this.emitNoSpace((<ts.Identifier>propAssign.name).text);
-          this.emitNoSpace('"');
-        } else {
-          this.visit(propAssign.name);
-        }
-        this.emit(':');
-        this.visit(propAssign.initializer);
-        break;
-      case ts.SyntaxKind.ShorthandPropertyAssignment:
-        let shorthand = <ts.ShorthandPropertyAssignment>node;
-        this.emitNoSpace(' "');
-        this.emitNoSpace(shorthand.name.text);
-        this.emitNoSpace('"');
-        this.emit(':');
-        this.visit(shorthand.name);
-        break;
-
-      case ts.SyntaxKind.TrueKeyword:
-        this.emit('true');
-        break;
-      case ts.SyntaxKind.FalseKeyword:
-        this.emit('false');
-        break;
-      case ts.SyntaxKind.NullKeyword:
-        this.emit('null');
-        break;
-      case ts.SyntaxKind.RegularExpressionLiteral:
-        this.emit('new RegExp (');
-        this.emit('r\'');
-        let regExp = (<ts.LiteralExpression>node).text;
-        let slashIdx = regExp.lastIndexOf('/');
-        let flags = regExp.substring(slashIdx + 1);
-        regExp = regExp.substring(1, slashIdx);            // cut off /.../ chars.
-        regExp = regExp.replace(/'/g, '\' + "\'" + r\'');  // handle nested quotes by concatenation.
-        this.emitNoSpace(regExp);
-        this.emitNoSpace('\'');
-        if (flags.indexOf('g') === -1) {
-          // Dart RegExps are always global, so JS regexps must use 'g' so that semantics match.
-          this.reportError(node, 'Regular Expressions must use the //g flag');
-        }
-        if (flags.indexOf('m') !== -1) {
-          this.emit(', multiLine: true');
-        }
-        if (flags.indexOf('i') !== -1) {
-          this.emit(', caseSensitive: false');
-        }
-        this.emit(')');
-        break;
-      case ts.SyntaxKind.ThisKeyword:
-        this.emit('this');
-        break;
-
-      default:
-        return false;
-    }
-    return true;
-  }
-
-  private shouldBeConst(n: ts.Node): boolean {
-    return this.hasAncestor(n, ts.SyntaxKind.Decorator) || this.fc.isInsideConstExpr(n);
-  }
-
-  private escapeTextForTemplateString(n: ts.Node): string {
-    return (<ts.StringLiteral>n).text.replace(/\\/g, '\\\\').replace(/([$'])/g, '\\$1');
-  }
-
-  private handleReifiedArray(node: ts.ArrayLiteralExpression) {
-    if (node.parent.kind !== ts.SyntaxKind.TypeAssertionExpression) return;
-    let ta = <ts.TypeAssertion>node.parent;
-    if (ta.type.kind !== ts.SyntaxKind.ArrayType) return;
-    this.emit('<');
-    this.visit((<ts.ArrayTypeNode>ta.type).elementType);
-    this.emit('>');
-    return true;
-  }
-
-
-  private handleReifiedMap(node: ts.ObjectLiteralExpression) {
-    if (node.parent.kind !== ts.SyntaxKind.TypeAssertionExpression) return;
-    let ta = <ts.TypeAssertion>node.parent;
-    if (ta.type.kind !== ts.SyntaxKind.TypeLiteral) return;
-    let it = this.maybeDestructureIndexType(<ts.TypeLiteralNode>ta.type);
-    if (!it) {
-      this.reportError(node, 'expected {[k]: v} type on object literal');
-      return;
-    }
-    this.emit('<');
-    this.visit(it[0]);
-    this.emit(',');
-    this.visit(it[1]);
-    this.emit('>');
-  }
-}