"Get latest changes from dart-archive/ts2dart master #1"

.arc/npm-test/__phutil_library_init__.php

@@ -0,0 +1,3 @@
+<?php
+
+phutil_register_library('npm-test', __FILE__);

.arc/npm-test/__phutil_library_map__.php

@@ -0,0 +1,18 @@
+<?php
+
+/**
+ * This file is automatically generated. Use 'arc liberate' to rebuild it.
+ *
+ * @generated
+ * @phutil-library-version 2
+ */
+phutil_register_library_map(array(
+  '__library_version__' => 2,
+  'class' => array(
+    'NpmUnitTestEngine' => 'src/NpmUnitTestEngine.php',
+  ),
+  'function' => array(),
+  'xmap' => array(
+    'NpmUnitTestEngine' => 'ArcanistUnitTestEngine',
+  ),
+));

.arc/npm-test/src/NpmUnitTestEngine.php

@@ -0,0 +1,20 @@
+<?php
+class NpmUnitTestEngine extends ArcanistUnitTestEngine {
+  public function run() {
+    $retval = 0;
+    system('npm test', $retval);
+    $result = new ArcanistUnitTestResult();
+    $result->setName('npm test');
+    if ($retval == 0) {
+      $result->setResult(ArcanistUnitTestResult::RESULT_PASS);
+    } else {
+      $result->setResult(ArcanistUnitTestResult::RESULT_FAIL);
+    }
+    return array($result);
+  }
+
+  public function shouldEchoTestResults() {
+    return false;
+  }
+}
+?>

.arcconfig

@@ -0,0 +1,8 @@
+{
+  "base": "git:origin/master",
+  "phabricator.uri" : "https://reviews.angular.io/",
+  "load": [
+    ".arc/npm-test"
+  ],
+  "unit.engine": "NpmUnitTestEngine"
+}

.gitignore

@@ -1,5 +1,4 @@
 # Compiled JS
-build
 
 # Logs
 logs
@@ -9,6 +8,7 @@ logs
 pids
 *.pid
 *.seed
+.phutil_module_cache
 
 # Type definitions installed with tsd
 typings
@@ -30,3 +30,7 @@ node_modules
 
 # Users Environment Variables
 .lock-wscript
+
+# IDEs
+.idea/
+/ts2dart.iml

README.md

@@ -1,8 +1,12 @@
 # TypeScript to Dart transpiler [![Build Status](https://travis-ci.org/angular/ts2dart.svg?branch=master)](https://travis-ci.org/angular/ts2dart)
 
+ts2dart is a TypeScript to Dart transpiler. It's mainly used to translate Angular 2 from TypeScript
+to Dart for its Dart user base.
 
-ts2dart is a TypeScript to Dart transpiler. It's in its very early days and under heavy development,
-not ready for production use.
+## Usage
+
+- To install as Command Line Tool execute: `npm i -g ts2dart`
+- Once installed you could run it doing: `ts2dart inputFile.ts`
 
 ## Installation
 
@@ -15,3 +19,15 @@ not ready for production use.
 - `gulp test.e2e` executes the e2e tests,
 - `gulp test.check-format` checks the source code formatting using `clang-format`,
 - `gulp test` runs unit tests, e2e tests and checks the source code formatting.
+
+## Phabricator Reviews
+
+You can send pull requests via Github, or by creating a Phabricator diff on
+https://reviews.angular.io. Both are fine, though Phabricator has a nicer code review UI.
+
+To create a Phabricator diff:
+
+- create an account on https://reviews.angular.io
+- install [Arcanist](https://secure.phabricator.com/book/phabricator/article/arcanist/)
+- run `arc diff` to upload a diff (= pull request). This will also run all tests.
+- get it reviewed by entering a "Reviewer", e.g. "mprobst", "alexeagle", "viks", ...

build/definitions/base.d.ts

@@ -0,0 +1,31 @@
+import * as ts from 'typescript';
+import { Transpiler } from './main';
+export declare type ClassLike = ts.ClassDeclaration | ts.InterfaceDeclaration;
+export declare function ident(n: ts.Node): string;
+export declare class TranspilerBase {
+    private transpiler;
+    private idCounter;
+    constructor(transpiler: Transpiler);
+    visit(n: ts.Node): void;
+    emit(s: string): void;
+    emitBefore(s: string, search: string): void;
+    emitNoSpace(s: string): void;
+    reportError(n: ts.Node, message: string): void;
+    visitNode(n: ts.Node): boolean;
+    visitEach(nodes: ts.Node[]): void;
+    visitEachIfPresent(nodes?: ts.Node[]): void;
+    visitList(nodes: ts.Node[], separator?: string): void;
+    uniqueId(name: string): string;
+    assert(c: ts.Node, condition: boolean, reason: string): void;
+    getAncestor(n: ts.Node, kind: ts.SyntaxKind): ts.Node;
+    hasAncestor(n: ts.Node, kind: ts.SyntaxKind): boolean;
+    hasAnnotation(decorators: ts.NodeArray<ts.Decorator>, name: string): boolean;
+    hasFlag(n: {
+        flags: number;
+    }, flag: ts.NodeFlags): boolean;
+    maybeDestructureIndexType(node: ts.TypeLiteralNode): [ts.TypeNode, ts.TypeNode];
+    getRelativeFileName(fileName: string): string;
+    maybeVisitTypeArguments(n: {
+        typeArguments?: ts.NodeArray<ts.TypeNode>;
+    }): void;
+}

build/definitions/call.d.ts

@@ -0,0 +1,28 @@
+import ts = require('typescript');
+import base = require('./base');
+import ts2dart = require('./main');
+import { FacadeConverter } from './facade_converter';
+export default class CallTranspiler extends base.TranspilerBase {
+    private fc;
+    constructor(tr: ts2dart.Transpiler, fc: FacadeConverter);
+    visitNode(node: ts.Node): boolean;
+    private visitCall(c);
+    private handleNamedParamsCall(c);
+    /**
+     * Handles constructor initializer lists and bodies.
+     *
+     * <p>Dart's super() ctor calls have to be moved to the constructors initializer list, and `const`
+     * constructors must be completely empty, only assigning into fields through the initializer list.
+     * The code below finds super() calls and handles const constructors, marked with the special
+     * `@CONST` annotation on the class.
+     *
+     * <p>Not emitting super() calls when traversing the ctor body is handled by maybeHandleSuperCall
+     * below.
+     */
+    private visitConstructorBody(ctor);
+    /**
+     * Checks whether `callExpr` is a super() call that should be ignored because it was already
+     * handled by `maybeEmitSuperInitializer` above.
+     */
+    private maybeHandleSuperCall(callExpr);
+}

build/definitions/declaration.d.ts

@@ -0,0 +1,29 @@
+import * as ts from 'typescript';
+import * as base from './base';
+import { FacadeConverter } from './facade_converter';
+import { Transpiler } from './main';
+export default class DeclarationTranspiler extends base.TranspilerBase {
+    private fc;
+    private enforceUnderscoreConventions;
+    constructor(tr: Transpiler, fc: FacadeConverter, enforceUnderscoreConventions: boolean);
+    visitNode(node: ts.Node): boolean;
+    private visitVariableDeclarationType(varDecl);
+    private visitFunctionLike(fn, accessor?);
+    private visitParameters(parameters);
+    /**
+     * Visit a property declaration.
+     * In the special case of property parameters in a constructor, we also allow a parameter to be
+     * emitted as a property.
+     */
+    private visitProperty(decl, isParameter?);
+    private visitClassLike(keyword, decl);
+    private visitDecorators(decorators);
+    private visitDeclarationMetadata(decl);
+    private visitNamedParameter(paramDecl);
+    private getInitializers(paramDecl);
+    /**
+     * Handles a function typedef-like interface, i.e. an interface that only declares a single
+     * call signature, by translating to a Dart `typedef`.
+     */
+    private visitFunctionTypedefInterface(name, signature, typeParameters);
+}

build/definitions/expression.d.ts

@@ -0,0 +1,10 @@
+import * as ts from 'typescript';
+import * as base from './base';
+import { FacadeConverter } from './facade_converter';
+import { Transpiler } from './main';
+export default class ExpressionTranspiler extends base.TranspilerBase {
+    private fc;
+    constructor(tr: Transpiler, fc: FacadeConverter);
+    visitNode(node: ts.Node): boolean;
+    visitAndWrapAsInt(n: ts.Expression): void;
+}

build/definitions/facade_converter.d.ts

@@ -0,0 +1,69 @@
+import * as ts from 'typescript';
+import * as base from './base';
+import { Transpiler } from './main';
+export declare class FacadeConverter extends base.TranspilerBase {
+    private tc;
+    private defaultLibLocation;
+    private candidateProperties;
+    private candidateTypes;
+    private genericMethodDeclDepth;
+    constructor(transpiler: Transpiler);
+    initializeTypeBasedConversion(tc: ts.TypeChecker, opts: ts.CompilerOptions, host: ts.CompilerHost): void;
+    private extractPropertyNames(m, candidates);
+    private resolveModuleNames(opts, host, m);
+    /**
+     * To avoid strongly referencing the Provider class (which could bloat binary size), Angular 2
+     * write providers as object literals. However the Dart transformers don't recognize this, so
+     * ts2dart translates the special syntax `/* @ts2dart_Provider * / {provide: Class, param1: ...}`
+     * into `const Provider(Class, param1: ...)`.
+     */
+    maybeHandleProvider(ole: ts.ObjectLiteralExpression): boolean;
+    maybeHandleCall(c: ts.CallExpression): boolean;
+    handlePropertyAccess(pa: ts.PropertyAccessExpression): boolean;
+    /**
+     * Searches for type references that require extra imports and emits the imports as necessary.
+     */
+    emitExtraImports(sourceFile: ts.SourceFile): void;
+    private emitImports(n, libraries, emitted, sourceFile);
+    pushTypeParameterNames(n: ts.FunctionLikeDeclaration): void;
+    popTypeParameterNames(n: ts.FunctionLikeDeclaration): void;
+    resolvePropertyTypes(tn: ts.TypeNode): ts.Map<ts.PropertyDeclaration>;
+    /**
+     * The Dart Development Compiler (DDC) has a syntax extension that uses comments to emulate
+     * generic methods in Dart. ts2dart has to hack around this and keep track of which type names
+     * in the current scope are actually DDC type parameters and need to be emitted in comments.
+     *
+     * TODO(martinprobst): Remove this once the DDC hack has made it into Dart proper.
+     */
+    private isGenericMethodTypeParameterName(name);
+    visitTypeName(typeName: ts.EntityName): void;
+    shouldEmitNew(c: ts.CallExpression): boolean;
+    private getCallInformation(c);
+    private getHandler<T>(n, symbol, m);
+    private getFileAndName(n, originalSymbol);
+    private isNamedDefaultLibType(node, qname);
+    private reportMissingType(n, ident);
+    private static DECLARATIONS;
+    isInsideConstExpr(node: ts.Node): boolean;
+    isConstClass(decl: base.ClassLike): boolean;
+    /**
+     * isConstExpr returns true if the passed in expression itself is a const expression. const
+     * expressions are marked by the special comment @ts2dart_const (expr), or by the special
+     * function call CONST_EXPR.
+     */
+    isConstExpr(node: ts.Node): boolean;
+    hasConstComment(node: ts.Node): boolean;
+    private hasMarkerComment(node, markerText);
+    private emitMethodCall(name, args?);
+    private emitCall(name, args?);
+    private stdlibTypeReplacements;
+    private tsToDartTypeNames;
+    private es6Promises;
+    private es6Collections;
+    private stdlibHandlers;
+    private callHandlerReplaceNew;
+    private callHandlers;
+    private es6CollectionsProp;
+    private es6PromisesProp;
+    private propertyHandlers;
+}

build/definitions/literal.d.ts

@@ -0,0 +1,13 @@
+import * as ts from 'typescript';
+import * as base from './base';
+import { FacadeConverter } from './facade_converter';
+import { Transpiler } from './main';
+export default class LiteralTranspiler extends base.TranspilerBase {
+    private fc;
+    constructor(tr: Transpiler, fc: FacadeConverter);
+    visitNode(node: ts.Node): boolean;
+    private shouldBeConst(n);
+    private escapeTextForTemplateString(n);
+    private handleReifiedArray(node);
+    private handleReifiedMap(node);
+}

build/definitions/main.d.ts

@@ -0,0 +1,68 @@
+import * as ts from 'typescript';
+export interface TranspilerOptions {
+    /**
+     * Fail on the first error, do not collect multiple. Allows easier debugging as stack traces lead
+     * directly to the offending line.
+     */
+    failFast?: boolean;
+    /** Whether to generate 'library a.b.c;' names from relative file paths. */
+    generateLibraryName?: boolean;
+    /** Whether to generate source maps. */
+    generateSourceMap?: boolean;
+    /** A tsconfig.json to use to configure TypeScript compilation. */
+    tsconfig?: string;
+    /**
+     * A base path to relativize absolute file paths against. This is useful for library name
+     * generation (see above) and nicer file names in error messages.
+     */
+    basePath?: string;
+    /**
+     * Translate calls to builtins, i.e. seemlessly convert from `Array` to `List`, and convert the
+     * corresponding methods. Requires type checking.
+     */
+    translateBuiltins?: boolean;
+    /**
+     * Enforce conventions of public/private keyword and underscore prefix
+     */
+    enforceUnderscoreConventions?: boolean;
+}
+export declare const COMPILER_OPTIONS: ts.CompilerOptions;
+export declare class Transpiler {
+    private options;
+    private output;
+    private currentFile;
+    private lastCommentIdx;
+    private errors;
+    private transpilers;
+    private fc;
+    constructor(options?: TranspilerOptions);
+    /**
+     * Transpiles the given files to Dart.
+     * @param fileNames The input files.
+     * @param destination Location to write files to. Creates files next to their sources if absent.
+     */
+    transpile(fileNames: string[], destination?: string): void;
+    translateProgram(program: ts.Program, host: ts.CompilerHost): {
+        [path: string]: string;
+    };
+    private getCompilerOptions();
+    private createCompilerHost();
+    getOutputPath(filePath: string, destinationRoot: string): string;
+    private translate(sourceFile);
+    private formatCode(code, context);
+    private checkForErrors(program);
+    private diagnosticToString(diagnostic);
+    /**
+     * Returns `filePath`, relativized to the program's `basePath`.
+     * @param filePath path to relativize.
+     */
+    getRelativeFileName(filePath: string): string;
+    emit(s: string): void;
+    emitBefore(s: string, search: string): void;
+    emitNoSpace(s: string): void;
+    reportError(n: ts.Node, message: string): void;
+    visit(node: ts.Node): void;
+    private normalizeSlashes(path);
+    private translateComment(comment);
+}
+export declare function getModuleResolver(compilerHost: ts.CompilerHost): (moduleNames: string[], containingFile: string) => ts.ResolvedModule[];

build/definitions/mkdirp.d.ts

@@ -0,0 +1 @@
+export default function mkdirP(p: string): void;

build/definitions/module.d.ts

@@ -0,0 +1,16 @@
+import * as ts from 'typescript';
+import * as base from './base';
+import { FacadeConverter } from './facade_converter';
+import { Transpiler } from './main';
+export default class ModuleTranspiler extends base.TranspilerBase {
+    private fc;
+    private generateLibraryName;
+    constructor(tr: Transpiler, fc: FacadeConverter, generateLibraryName: boolean);
+    visitNode(node: ts.Node): boolean;
+    private static isIgnoredImport(e);
+    private visitExternalModuleReferenceExpr(expr);
+    private isEmptyImport(n);
+    private filterImports(ns);
+    private static DART_RESERVED_WORDS;
+    getLibraryName(fileName: string): string;
+}

build/definitions/statement.d.ts

@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import * as base from './base';
+import { Transpiler } from './main';
+export default class StatementTranspiler extends base.TranspilerBase {
+    constructor(tr: Transpiler);
+    visitNode(node: ts.Node): boolean;
+}

build/definitions/type.d.ts

@@ -0,0 +1,10 @@
+import * as ts from 'typescript';
+import * as base from './base';
+import { FacadeConverter } from './facade_converter';
+import { Transpiler } from './main';
+export default class TypeTranspiler extends base.TranspilerBase {
+    private fc;
+    constructor(tr: Transpiler, fc: FacadeConverter);
+    visitNode(node: ts.Node): boolean;
+    isReifiedTypeLiteral(node: ts.TypeAssertion): boolean;
+}