typenative 0.0.10 → 0.0.12

package/README.md

@@ -4,7 +4,8 @@ Build native applications using Typescript.
 
 ## PreRequisites
 
-- Go 1.21 or newer.
+- [Nodejs v20](https://nodejs.org/en) or newer.
+- [Go 1.21](https://go.dev/doc/install) or newer.
 
 ## Get Started
 
@@ -12,6 +13,12 @@ Build native applications using Typescript.
 - Run `npx typenative --source test.ts --script`
 - See your message in the terminal
 
+## Create a TypeNative Project
+
+- Run `npx typenative --new`
+- Give your project a name
+- Start writing code
+
 ## Typescript Syntax Support
 
 TypeNative currently supports a subset of TypeScript syntax elements that are transpiled to Go code:
@@ -33,18 +40,24 @@ TypeNative currently supports a subset of TypeScript syntax elements that are tr
 | Increment/Decrement | ✅ | `++`, `--` |
 | **Control Flow** |  |  |
 | For loops | ✅ | Standard `for` loops |
+| For...of loops | ✅ | Iteration over arrays |
+| While loops | ✅ | Transpiled to Go's `for` loops |
+| Do...while loops | ✅ | Implemented with conditional break |
+| If/Else statements | ✅ | Fully supported |
+| Switch statements | ✅ | Case and default statements |
 | **Data Structures** |  |  |
 | Arrays | ✅ | Basic array operations |
+| Array methods | ✅ | `push` supported |
 | **Functions** |  |  |
+| Function declarations | ✅ | Transpiled to Go functions |
+| Arrow Functions | ✅ | Transpiled to anonymous functions |
 | console.log | ✅ | Mapped to `fmt.Println` |
+| console.time/timeEnd | ✅ | Performance measurement |
+| Math.random | ✅ | Mapped to Go's `rand.Float64()` |
+| Math.floor | ✅ | Mapped to Go's `math.Floor()` |
 | **Unsupported Features** |  |  |
 | Classes | ❌ | Not implemented |
 | Interfaces | ❌ | Not implemented |
-| Functions | ❌ | Custom function definitions not supported |
-| Arrow Functions | ❌ | Not implemented |
-| If/Else statements | ❌ | Not implemented |
-| While/Do loops | ❌ | Not implemented |
-| Switch statements | ❌ | Not implemented |
 | Async/Await | ❌ | Not implemented |
 | Modules/Imports | ❌ | Not implemented |
 | Generics | ❌ | Not implemented |

package/bin/index.js

@@ -1,53 +1,150 @@
 #!/usr/bin/env node
 import inquirer from 'inquirer';
-import shell from 'shelljs';
 import fs from 'fs-extra';
 import path from 'path';
+import { execa } from 'execa';
 import { transpileToNative } from './transpiler.js';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 (async function main() {
     const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
-    const targetIndex = process.argv.findIndex((a) => a === '--source');
-    const target = targetIndex > -1 ? process.argv[targetIndex + 1] : null;
+    const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
+    const sourceIndex = process.argv.findIndex((a) => a === '--source');
+    const source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
+    const outputIndex = process.argv.findIndex((a) => a === '--output');
+    const output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
     const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'Enter Project Name:',
+            when: newCommand,
+            validate: (input) => input.trim() !== ''
+        },
+        {
+            type: 'confirm',
+            name: 'installDependencies',
+            message: 'Do you want to install dependencies?',
+            when: newCommand
+        },
         {
             type: 'input',
             name: 'path',
             message: 'Enter Path to typescript main file:',
-            when: !scriptMode && !target
+            when: !newCommand && !scriptMode && !source,
+            validate: (input) => input.trim() !== ''
         },
         {
             type: 'input',
             name: 'output',
             message: 'Enter Output Path:',
-            when: !scriptMode && !target
+            when: !newCommand && !scriptMode && !output,
+            validate: (input) => input.trim() !== ''
         },
         {
             type: 'editor',
             name: 'tsCode',
-            message: 'Write your typescript code and save',
-            when: scriptMode && !target
+            message: 'Write your typescript code here:',
+            when: !newCommand && scriptMode && !source,
+            default: `console.log('Hello, World!');`
         }
     ]);
+    if (newCommand) {
+        const projectName = answers.projectName.trim();
+        await fs.ensureDir(projectName);
+        await fs.writeFile(path.join(projectName, 'main.ts'), `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`, { encoding: 'utf-8' });
+        await fs.writeFile(path.join(projectName, 'tsconfig.json'), getTsConfig(), {
+            encoding: 'utf-8'
+        });
+        await fs.writeFile(path.join(projectName, 'package.json'), getPackageJson(projectName), {
+            encoding: 'utf-8'
+        });
+        await fs.writeFile(path.join(projectName, '.gitignore'), getGitIgnore(), {
+            encoding: 'utf-8'
+        });
+        await fs.writeFile(path.join(projectName, 'README.md'), getReadMe(projectName), {
+            encoding: 'utf-8'
+        });
+        console.log(`Project "${projectName}" created successfully!`);
+        if (answers.installDependencies) {
+            console.log('Installing dependencies...');
+            await execa('npm install', { cwd: projectName, stdio: 'inherit' });
+            console.log('Dependencies installed successfully!');
+        }
+        return;
+    }
     const tsCode = answers.tsCode
         ? answers.tsCode
-        : await fs.readFile(target ?? answers.path, { encoding: 'utf-8' });
+        : await fs.readFile(source ?? answers.path, { encoding: 'utf-8' });
     const nativeCode = transpileToNative(tsCode);
     await fs.ensureDir('dist');
     await fs.writeFile('dist/code.go', nativeCode, { encoding: 'utf-8' });
-    shell.exec('go build -o dist/native.exe dist/code.go');
+    await execa('go build -o dist/native.exe dist/code.go', {
+        stdio: 'inherit'
+    });
     // await fs.remove('dist/code.go');
-    if (answers.output) {
-        await fs.copy('dist/native.exe', answers.output, { overwrite: true });
-        await fs.remove('dist/native.exe');
-    }
     if (scriptMode) {
-        shell.exec(path.join('dist', 'native.exe'));
-        await fs.remove('dist/native.exe');
+        await execa('dist/native.exe', {
+            stdio: 'inherit'
+        });
+        //await fs.remove('dist/native.exe');
     }
-    else {
-        console.log('DONE');
+    else if (output || answers.output) {
+        await fs.copy('dist/native.exe', output ?? answers.output, { overwrite: true });
+        //await fs.remove('dist/native.exe');
+        console.log(`Created native executable at: ${output ?? answers.output}`);
     }
 })();
+function getPackageJson(projectName) {
+    const pckg = {
+        name: projectName,
+        version: '1.0.0',
+        scripts: {
+            execute: 'npx typenative --source main.ts --script',
+            build: `npx typenative --source main.ts --output bin/${projectName}.exe`
+        },
+        devDependencies: {
+            typenative: '^0.12.0'
+        }
+    };
+    return JSON.stringify(pckg, null, 2);
+}
+function getTsConfig() {
+    const tsConfig = {
+        include: ['*.ts'],
+        compilerOptions: {
+            target: 'es2020',
+            lib: [],
+            types: ['./node_modules/types/typenative.d.ts'],
+            rootDir: '.',
+            strict: true,
+            noImplicitAny: true
+        }
+    };
+    return JSON.stringify(tsConfig, null, 2);
+}
+function getGitIgnore() {
+    return `# TypeNative generated files
+node_modules/
+dist/
+bin/
+`;
+}
+function getReadMe(projectName) {
+    return `# ${projectName}
+
+This project was created using TypeNative, a tool to transpile TypeScript code to native Go code.
+
+## How to Run
+
+1. Install dependencies: \`npm install\`
+2. Build the project: \`npm run build\`
+3. Run the executable: \`./dist/native.exe\`
+
+## How to Use
+
+You can write your TypeScript code in the \`main.ts\` file. The code will be transpiled to Go and compiled into a native executable.
+You can also run the code directly in script mode using \`npm run execute\`.
+`;
+}

package/bin/transpiler.js

@@ -1,111 +1,253 @@
-import ts from 'typescript';
-let TypeCheker;
-export function transpileToNative(code) {
-    const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
-    TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
+import ts from 'typescript';
+let TypeCheker;
+const importedPackages = new Set();
+let outsideNodes = [];
+export function transpileToNative(code) {
+    const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
+    importedPackages.clear();
+    outsideNodes = [];
+    const transpiledCode = visit(sourceFile, { addFunctionOutside: true });
+    const transpiledCodeOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
     return `package main
 
-import "fmt"
+${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
 
 func main() {
-    ${visit(sourceFile)}
-}`;
-}
-export function visit(node, inline = false) {
-    let code = '';
-    if (ts.isIdentifier(node)) {
-        return node.text;
-    }
-    else if (ts.isStringLiteral(node)) {
-        return `"${node.text}"`;
-    }
-    else if (ts.isNumericLiteral(node)) {
-        return `float64(${node.text})`;
-    }
-    else if (ts.isToken(node) && node.kind === ts.SyntaxKind.TrueKeyword) {
-        return `true`;
-    }
-    else if (ts.isToken(node) && node.kind === ts.SyntaxKind.FalseKeyword) {
-        return `false`;
-    }
-    else if (ts.isBlock(node)) {
-        return `{\n\t\t${node.statements.map((n) => visit(n)).join('\t')}}\n\t`;
-    }
-    else if (ts.isPropertyAccessExpression(node)) {
-        return `${visit(node.expression)}.${visit(node.name)}`;
-    }
-    else if (ts.isVariableDeclaration(node)) {
-        const type = getType(node.type);
-        const initializer = node.initializer ? `= ${visit(node.initializer)}` : '';
-        return `${type === ':' ? '' : 'var'} ${visit(node.name)} ${type}${type === ':' ? '' : ' '}${initializer}`;
-    }
-    else if (ts.isCallExpression(node)) {
-        const expr = visit(node.expression);
-        return `${getFunction(expr)}(${node.arguments.map((a) => visit(a)).join(',')})`;
-    }
-    else if (ts.isPrefixUnaryExpression(node)) {
-        return `${getOperatorText(node.operator)}${visit(node.operand)}`;
-    }
-    else if (ts.isPostfixUnaryExpression(node)) {
-        return `${visit(node.operand, true)}${getOperatorText(node.operator)}`;
-    }
-    else if (ts.isBinaryExpression(node)) {
-        return `${visit(node.left)} ${node.operatorToken.getText()} ${visit(node.right)}`;
-    }
-    else if (ts.isParenthesizedExpression(node)) {
-        return `(${visit(node.expression)})`;
-    }
-    else if (ts.isVariableDeclarationList(node)) {
-        return (node.declarations.map((n) => visit(n)).join(inline ? ';' : ';\n\t') + (inline ? ';' : ';\n\t'));
-    }
-    else if (ts.isExpressionStatement(node)) {
-        return visit(node.expression) + (inline ? ';' : ';\n\t');
-    }
-    else if (ts.isForStatement(node)) {
-        return `for${visit(node.initializer, true)} ${visit(node.condition, true)}; ${visit(node.incrementor, true)}${visit(node.statement)}`;
-    }
-    console.log(ts.SyntaxKind[node.kind], node.getText());
-    ts.forEachChild(node, (subNode) => {
-        code += visit(subNode);
-        return null;
-    });
-    return code;
-}
-function getType(typeNode) {
-    const type = TypeCheker.getTypeFromTypeNode(typeNode);
-    const typeName = TypeCheker.typeToString(type);
-    switch (typeName) {
-        case 'number':
-            return 'float64';
-        case 'boolean':
-            return 'bool';
-        case 'any':
-            return ':';
-        default:
-            return typeName;
-    }
-}
-function getFunction(expr) {
-    switch (expr) {
-        case 'console.log':
-            return 'fmt.Println';
-        default:
-            return expr;
-    }
-}
-function getOperatorText(operator) {
-    switch (operator) {
-        case ts.SyntaxKind.PlusToken:
-            return '+';
-        case ts.SyntaxKind.MinusToken:
-            return '-';
-        case ts.SyntaxKind.TildeToken:
-            return '~';
-        case ts.SyntaxKind.ExclamationToken:
-            return '!';
-        case ts.SyntaxKind.PlusPlusToken:
-            return '++';
-        case ts.SyntaxKind.MinusMinusToken:
-            return '--';
-    }
-}
+    ${transpiledCode.trim()}
+}
+ 
+${transpiledCodeOutside.trim()}`;
+}
+export function visit(node, options = {}) {
+    let code = '';
+    if (ts.isSourceFile(node)) {
+        return node.statements
+            .map((n) => visit(n, { addFunctionOutside: true }))
+            .filter((n) => !!n)
+            .join(options.inline ? '' : '\n\t');
+    }
+    else if (ts.isIdentifier(node)) {
+        return node.text;
+    }
+    else if (ts.isStringLiteral(node)) {
+        return `"${node.text}"`;
+    }
+    else if (ts.isNumericLiteral(node)) {
+        return `float64(${node.text})`;
+    }
+    else if (ts.isToken(node) && node.kind === ts.SyntaxKind.TrueKeyword) {
+        return `true`;
+    }
+    else if (ts.isToken(node) && node.kind === ts.SyntaxKind.FalseKeyword) {
+        return `false`;
+    }
+    else if (ts.isArrayLiteralExpression(node)) {
+        const type = ts.isVariableDeclaration(node.parent) ? getType(node.parent.type, true) : '';
+        return `[]${type} {${node.elements.map((e) => visit(e)).join(', ')}}`;
+    }
+    else if (ts.isBlock(node)) {
+        return `{\n\t\t${node.statements.map((n) => visit(n)).join('\t')}${options.extraBlockContent ?? ''}}${options.inline ? '' : '\n\t'}`;
+    }
+    else if (ts.isElementAccessExpression(node)) {
+        return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
+    }
+    else if (ts.isPropertyAccessExpression(node)) {
+        const leftSide = visit(node.expression);
+        const rightSide = visit(node.name);
+        return getAcessString(leftSide, rightSide);
+    }
+    else if (ts.isVariableDeclaration(node)) {
+        const type = getType(node.type);
+        const initializer = node.initializer ? `= ${visit(node.initializer)}` : '';
+        return `${type === ':' ? '' : 'var '}${visit(node.name)} ${type}${type === ':' ? '' : ' '}${initializer}`;
+    }
+    else if (ts.isCallExpression(node)) {
+        const caller = visit(node.expression);
+        const args = node.arguments.map((a) => visit(a));
+        return getCallString(caller, args);
+    }
+    else if (ts.isPrefixUnaryExpression(node)) {
+        return `${getOperatorText(node.operator)}${visit(node.operand)}`;
+    }
+    else if (ts.isPostfixUnaryExpression(node)) {
+        return `${visit(node.operand, { inline: true })}${getOperatorText(node.operator)}`;
+    }
+    else if (ts.isBinaryExpression(node)) {
+        return `${visit(node.left)} ${node.operatorToken.getText()} ${visit(node.right)}`;
+    }
+    else if (ts.isParenthesizedExpression(node)) {
+        return `(${visit(node.expression)})`;
+    }
+    else if (ts.isVariableDeclarationList(node)) {
+        return (node.declarations.map((n) => visit(n)).join(options.inline ? ';' : ';\n\t') +
+            (options.inline ? '' : ';\n\t'));
+    }
+    else if (ts.isExpressionStatement(node)) {
+        return visit(node.expression) + (options.inline ? '' : ';\n\t');
+    }
+    else if (ts.isForStatement(node)) {
+        return `for ${visit(node.initializer, { inline: true })}; ${visit(node.condition, {
+            inline: true
+        })}; ${visit(node.incrementor, { inline: true })}${visit(node.statement)}`;
+    }
+    else if (ts.isForOfStatement(node)) {
+        return `for _,${visit(node.initializer, { inline: true })}= range ${visit(node.expression, {
+            inline: true
+        })}${visit(node.statement)}`;
+    }
+    else if (ts.isWhileStatement(node)) {
+        return `for ${visit(node.expression, { inline: true })}${visit(node.statement)}`;
+    }
+    else if (ts.isDoStatement(node)) {
+        const condition = `\tif !(${visit(node.expression, {
+            inline: true
+        })}) {\n\t\t\tbreak \n\t\t}\n\t`;
+        return `for ${visit(node.statement, { inline: true, extraBlockContent: condition })}`;
+    }
+    else if (ts.isIfStatement(node)) {
+        const condition = `if ${visit(node.expression, { inline: true })} ${visit(node.thenStatement, {
+            inline: !!node.elseStatement
+        })}`;
+        if (node.elseStatement) {
+            return `${condition} else ${visit(node.elseStatement)}`;
+        }
+        return condition;
+    }
+    else if (ts.isSwitchStatement(node)) {
+        return `switch ${visit(node.expression)} ${visit(node.caseBlock)}`;
+    }
+    else if (ts.isCaseBlock(node)) {
+        return `{\n\t\t${node.clauses.map((c) => visit(c)).join('\n\t\t')}\n\t}`;
+    }
+    else if (ts.isCaseClause(node)) {
+        const isFallThrough = !node.statements.some((c) => ts.isBreakStatement(c));
+        return `case ${visit(node.expression, { inline: true })}: \n\t\t\t${node.statements
+            .filter((n) => !ts.isBreakStatement(n))
+            .map((s) => visit(s))
+            .join('')}${isFallThrough ? 'fallthrough\n\t' : ''}`;
+    }
+    else if (ts.isDefaultClause(node)) {
+        return `default: \n\t\t\t${node.statements
+            .filter((n) => !ts.isBreakStatement(n))
+            .map((s) => visit(s))
+            .join('')}`;
+    }
+    else if (ts.isBreakStatement(node)) {
+        return 'break';
+    }
+    else if (ts.isReturnStatement(node)) {
+        return (`return ${node.expression ? visit(node.expression) : ''}` + (options.inline ? '' : ';\n\t'));
+    }
+    else if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+        if (options.addFunctionOutside) {
+            outsideNodes.push(node);
+            return '';
+        }
+        const name = visit(node.name, { inline: true });
+        const parameters = node.parameters
+            .map((p) => `${visit(p.name)} ${getType(p.type)}`)
+            .join(', ');
+        const returnType = node.type ? ` ${getType(node.type)}` : '';
+        if (options.isOutside) {
+            return `func ${name}(${parameters})${returnType} ${visit(node.body)}`;
+        }
+        return `${name} := func(${parameters})${returnType} ${visit(node.body)}`;
+    }
+    else if (ts.isArrowFunction(node)) {
+        const parameters = node.parameters
+            .map((p) => `${visit(p.name)} ${getType(p.type)}`)
+            .join(', ');
+        const returnType = node.type ? ` ${getType(node.type)}` : '';
+        return `func(${parameters})${returnType} ${visit(node.body)}`;
+    }
+    const syntaxKind = ts.SyntaxKind[node.kind];
+    if (!['FirstStatement', 'EndOfFileToken'].includes(syntaxKind)) {
+        console.log(ts.SyntaxKind[node.kind], node.getText());
+    }
+    ts.forEachChild(node, (subNode) => {
+        code += visit(subNode);
+    });
+    return code;
+}
+function getType(typeNode, getArrayType = false) {
+    const type = TypeCheker.getTypeFromTypeNode(typeNode);
+    let typeName = TypeCheker.typeToString(type);
+    const isArray = typeName.includes('[]');
+    if (isArray) {
+        if (getArrayType) {
+            typeName = typeName.replace('[]', '');
+        }
+        else {
+            return ':';
+        }
+    }
+    switch (typeName) {
+        case 'number':
+            return 'float64';
+        case 'boolean':
+            return 'bool';
+        case 'any':
+            return ':';
+        case 'void':
+            return '';
+        default:
+            return typeName;
+    }
+}
+function getAcessString(leftSide, rightSide) {
+    if (rightSide === 'length') {
+        return 'float64(len(arr))';
+    }
+    return `${leftSide}.${rightSide}`;
+}
+function getCallString(caller, args) {
+    if (caller === 'console.log') {
+        importedPackages.add('fmt');
+        return `fmt.Println(${args.join(', ')})`;
+    }
+    else if (caller === 'console.time') {
+        importedPackages.add('time');
+        return `${getTimerName(args[0])} := time.Now()`;
+    }
+    else if (caller === 'console.timeEnd') {
+        importedPackages.add('time');
+        importedPackages.add('fmt');
+        return `fmt.Println("Elapsed time:", time.Since(${getTimerName(args[0])}))`;
+    }
+    else if (caller === 'Math.random') {
+        importedPackages.add('math/rand');
+        return 'rand.Float64()';
+    }
+    else if (caller === 'Math.floor') {
+        importedPackages.add('math');
+        return `math.Floor(${args.join(', ')})`;
+    }
+    else if (caller.endsWith('.push')) {
+        const arrayName = caller.substring(0, caller.length - '.push'.length);
+        return `${arrayName} = append(${arrayName},${args.join(', ')})`;
+    }
+    return `${caller}(${args.join(', ')})`;
+}
+function getOperatorText(operator) {
+    switch (operator) {
+        case ts.SyntaxKind.PlusToken:
+            return '+';
+        case ts.SyntaxKind.MinusToken:
+            return '-';
+        case ts.SyntaxKind.TildeToken:
+            return '~';
+        case ts.SyntaxKind.ExclamationToken:
+            return '!';
+        case ts.SyntaxKind.PlusPlusToken:
+            return '++';
+        case ts.SyntaxKind.MinusMinusToken:
+            return '--';
+        default:
+            console.error('Did not find operator', operator);
+            return '';
+    }
+}
+function getTimerName(name) {
+    return `__timer_${name.replaceAll(' ', '_').replaceAll('"', '')}__`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typenative",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Build native applications using Typescript.",
   "type": "module",
   "bin": {
@@ -14,7 +14,14 @@
     "test": "node ./bin/index --source test/test.ts --script",
     "test2": "node ./bin/index --source test/test2.ts --script",
     "test3": "node ./bin/index --source test/test3.ts --script",
+    "test3_node": "tsc test/test3.ts && node test/test3.js && rimraf test/test3.js",
     "test4": "node ./bin/index --source test/test4.ts --script",
+    "test5": "node ./bin/index --source test/test5.ts --script",
+    "test6": "node ./bin/index --source test/test6.ts --script",
+    "test7": "node ./bin/index --source test/test7.ts --script",
+    "test8": "node ./bin/index --source test/test8.ts --script",
+    "test9": "node ./bin/index --source test/test9.ts --script",
+    "test10": "node ./bin/index --source test/test10.ts --script",
     "release": "npm publish"
   },
   "repository": {
@@ -31,12 +38,12 @@
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.8",
     "@types/node": "^22.15.21",
-    "@types/shelljs": "^0.8.16"
+    "rimraf": "^6.0.1"
   },
   "dependencies": {
+    "execa": "^9.5.3",
     "fs-extra": "^11.3.0",
     "inquirer": "^12.6.1",
-    "shelljs": "^0.10.0",
     "typescript": "^5.8.3"
   }
 }

package/types/typenative.d.ts

@@ -1,4 +1,33 @@
-interface Array<T> {
+interface SymbolConstructor {
+  readonly iterator: unique symbol;
+}
+
+declare var Symbol: SymbolConstructor;
+
+interface IteratorYieldResult<TYield> {
+  done?: false;
+  value: TYield;
+}
+
+interface IteratorReturnResult<TReturn> {
+  done: true;
+  value: TReturn;
+}
+
+type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
+
+interface Iterator<T, TReturn = any, TNext = any> {
+  // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+  next(...[value]: [] | [TNext]): IteratorResult<T, TReturn>;
+  return?(value?: TReturn): IteratorResult<T, TReturn>;
+  throw?(e?: any): IteratorResult<T, TReturn>;
+}
+
+interface IterableIterator<T, TReturn = any, TNext = any> extends Iterator<T, TReturn, TNext> {
+  [Symbol.iterator](): IterableIterator<T, TReturn, TNext>;
+}
+
+interface Array<T> extends IterableIterator<T> {
   /**
    * Gets or sets the length of the array. This is a number one higher than the highest index in the array.
    */
@@ -13,5 +42,13 @@ interface Array<T> {
 
 interface Console {
   log(...data: any[]): void;
+  time(label?: string): void;
+  timeEnd(label?: string): void;
 }
 declare var console: Console;
+
+interface Math {
+  random(): number;
+  floor(x: number): number;
+}
+declare var Math: Math;