fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-09 13:01:26 +00:00
Code Issues Projects Releases Wiki Activity

Ensure consistent variable modifiers

Browse Source 
'var' is a distinct local or mutable global, 'let' a shared local
This commit is contained in:
dcodeIO 2018-03-13 02:32:10 +01:00
parent 7ee6e1cf7b
commit 23a7db4dc3
33 changed files with 736 additions and 570 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dist/asc.js vendored
View File

File diff suppressed because one or more lines are too long

2
dist/assemblyscript.js vendored
View File

File diff suppressed because one or more lines are too long

2
dist/assemblyscript.js.map vendored
View File

File diff suppressed because one or more lines are too long

12
lib/tslint/asFormatter.ts
View File

@ -25,15 +25,15 @@ export class Formatter extends AbstractFormatter {
mapToMessages(failures: RuleFailure[]): string[] {
return failures.map((failure: RuleFailure) => {
const fileName = failure.getFileName();
const failureString = failure.getFailure();
const ruleName = failure.getRuleName();
const lineAndCharacter = failure.getStartPosition().getLineAndCharacter();
const positionTuple = `:${lineAndCharacter.line + 1}:${lineAndCharacter.character + 1}`;
var fileName = failure.getFileName();
var failureString = failure.getFailure();
var ruleName = failure.getRuleName();
var lineAndCharacter = failure.getStartPosition().getLineAndCharacter();
var positionTuple = `:${lineAndCharacter.line + 1}:${lineAndCharacter.character + 1}`;
if (this.lastSeverity == failure.getRuleSeverity() && this.lastFailure == failureString) {
return " in " + fileName + positionTuple;
} else {
var message = this.lastSeverity ? "\n" : "";
let message = this.lastSeverity ? "\n" : "";
switch (this.lastSeverity = failure.getRuleSeverity()) {
case "warning": {
message += colorYellow + "WARNING:" + colorReset;

62
lib/tslint/asVariablesRule.js Normal file
View File

@ -0,0 +1,62 @@
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
exports.__esModule = true;
var Lint = require("tslint");
var tsutils_1 = require("tsutils");
var Rule = /** @class */ (function (_super) {
__extends(Rule, _super);
function Rule() {
return _super !== null && _super.apply(this, arguments) || this;
}
Rule.prototype.apply = function (sourceFile) {
return this.applyWithWalker(new DiagnosticsWalker(sourceFile, this.getOptions()));
};
Rule.TOP_LEVEL_VAR = "Top-level variable should be 'var' (distinct local or global).";
Rule.BLOCK_LEVEL_LET = "Block-level variable should be 'let' (shared local).";
return Rule;
}(Lint.Rules.AbstractRule));
exports.Rule = Rule;
var DiagnosticsWalker = /** @class */ (function (_super) {
__extends(DiagnosticsWalker, _super);
function DiagnosticsWalker() {
return _super !== null && _super.apply(this, arguments) || this;
}
DiagnosticsWalker.prototype.visitVariableDeclarationList = function (node) {
if (tsutils_1.isVariableStatement(node.parent)) {
if (tsutils_1.isBlock(node.parent.parent)) {
if (tsutils_1.isFunctionScopeBoundary(node.parent.parent.parent) ||
tsutils_1.isNamespaceDeclaration(node.parent.parent.parent)) {
if (tsutils_1.getVariableDeclarationKind(node) == 1 /* Let */) {
this.addFailureAtNode(node, Rule.TOP_LEVEL_VAR);
}
}
else if (tsutils_1.getVariableDeclarationKind(node) == 0 /* Var */) {
this.addFailureAtNode(node, Rule.BLOCK_LEVEL_LET);
}
}
else if (tsutils_1.isSourceFile(node.parent.parent) ||
tsutils_1.isModuleBlock(node.parent.parent)) {
if (tsutils_1.getVariableDeclarationKind(node) == 1 /* Let */) {
this.addFailureAtNode(node, Rule.TOP_LEVEL_VAR);
}
}
else if (tsutils_1.getVariableDeclarationKind(node) == 0 /* Var */) {
this.addFailureAtNode(node, Rule.BLOCK_LEVEL_LET);
}
}
else if (tsutils_1.getVariableDeclarationKind(node) == 0 /* Var */) {
this.addFailureAtNode(node, Rule.BLOCK_LEVEL_LET);
}
_super.prototype.visitVariableDeclarationList.call(this, node);
};
return DiagnosticsWalker;
}(Lint.RuleWalker));

55
lib/tslint/asVariablesRule.ts Normal file
View File

@ -0,0 +1,55 @@
import * as ts from "typescript";
import * as Lint from "tslint";
import {
getVariableDeclarationKind,
VariableDeclarationKind,
isVariableStatement,
isBlock,
isFunctionScopeBoundary,
isSourceFile,
isNamespaceDeclaration,
isExportSpecifier,
isModuleBlock
} from "tsutils";
export class Rule extends Lint.Rules.AbstractRule {
static TOP_LEVEL_VAR = "Top-level variable should be 'var' (distinct local or global).";
static BLOCK_LEVEL_LET = "Block-level variable should be 'let' (shared local).";
apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
return this.applyWithWalker(new DiagnosticsWalker(sourceFile, this.getOptions()));
}
}
class DiagnosticsWalker extends Lint.RuleWalker {
visitVariableDeclarationList(node: ts.VariableDeclarationList): void {
if (isVariableStatement(node.parent)) {
if (isBlock(node.parent.parent)) {
if (
isFunctionScopeBoundary(node.parent.parent.parent) ||
isNamespaceDeclaration(node.parent.parent.parent)
) {
if (getVariableDeclarationKind(node) == VariableDeclarationKind.Let) {
this.addFailureAtNode(node, Rule.TOP_LEVEL_VAR);
}
} else if (getVariableDeclarationKind(node) == VariableDeclarationKind.Var) {
this.addFailureAtNode(node, Rule.BLOCK_LEVEL_LET);
}
} else if (
isSourceFile(node.parent.parent) ||
isModuleBlock(node.parent.parent)
) {
if (getVariableDeclarationKind(node) == VariableDeclarationKind.Let) {
this.addFailureAtNode(node, Rule.TOP_LEVEL_VAR);
}
} else if (getVariableDeclarationKind(node) == VariableDeclarationKind.Var) {
this.addFailureAtNode(node, Rule.BLOCK_LEVEL_LET);
}
} else if (getVariableDeclarationKind(node) == VariableDeclarationKind.Var) {
this.addFailureAtNode(node, Rule.BLOCK_LEVEL_LET);
}
super.visitVariableDeclarationList(node);
}
}

16
src/ast.ts
View File

@ -603,7 +603,7 @@ export abstract class Node {
stmt.members = members; setParent(members, stmt);
stmt.path = path;
if (path) {
var normalizedPath = normalizePath(path.value);
let normalizedPath = normalizePath(path.value);
if (path.value.startsWith(".")) { // relative
stmt.normalizedPath = resolvePath(
normalizedPath,
@ -1806,7 +1806,7 @@ export function addModifier(modifier: ModifierNode, modifiers: ModifierNode[] |
/** Gets a specific modifier from the specified set of modifiers. */
export function getModifier(kind: ModifierKind, modifiers: ModifierNode[] | null): ModifierNode | null {
if (modifiers) {
for (var i = 0, k = modifiers.length; i < k; ++i) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
if (modifiers[i].modifierKind == kind) {
return modifiers[i];
}
@ -1823,9 +1823,9 @@ export function hasModifier(kind: ModifierKind, modifiers: ModifierNode[] | null
/** Gets the first decorator by name within at set of decorators, if present. */
export function getFirstDecorator(name: string, decorators: DecoratorNode[] | null): DecoratorNode | null {
if (decorators) {
for (var i = 0, k = decorators.length; i < k; ++i) {
var decorator = decorators[i];
var expression = decorator.name;
for (let i = 0, k = decorators.length; i < k; ++i) {
let decorator = decorators[i];
let expression = decorator.name;
if (expression.kind == NodeKind.IDENTIFIER && (<IdentifierExpression>expression).text == name) {
return decorator;
}
@ -1879,15 +1879,15 @@ export function mangleInternalPath(path: string): string {
/** Sets the parent node on an array of nodes. */
function setParent(nodes: Node[], parent: Node): void {
for (var i = 0, k = nodes.length; i < k; ++i) {
for (let i = 0, k = nodes.length; i < k; ++i) {
nodes[i].parent = parent;
}
}
/** Sets the parent node on an array of nullable nodes. */
function setParentIfNotNull(nodes: (Node | null)[], parent: Node): void {
for (var i = 0, k = nodes.length; i < k; ++i) {
var node = nodes[i];
for (let i = 0, k = nodes.length; i < k; ++i) {
let node = nodes[i];
if (node) node.parent = parent;
}
}

2
src/builtins.ts
View File

@ -1904,7 +1904,7 @@ export function compileCall(
return arg0;
}
var abort = compileAbort(compiler, operands.length == 2 ? operands[1] : null, reportNode);
let abort = compileAbort(compiler, operands.length == 2 ? operands[1] : null, reportNode);
compiler.currentType = type.nonNullableType;

174
src/compiler.ts
View File

@ -212,9 +212,6 @@ export class Compiler extends DiagnosticEmitter {
/** Already processed file names. */
files: Set<string> = new Set();
/** Trampolines used where functions are called with omitted parameters. */
trampolines: Map<Function,Map<i32,string>> = new Map();
/** Compiles a {@link Program} to a {@link Module} using the specified options. */
static compile(program: Program, options: Options | null = null): Module {
return new Compiler(program, options).compile();
@ -255,7 +252,7 @@ export class Compiler extends DiagnosticEmitter {
// compile entry file(s) while traversing to reachable elements
var sources = program.sources;
for (var i = 0, k = sources.length; i < k; ++i) {
for (let i = 0, k = sources.length; i < k; ++i) {
if (sources[i].isEntry) {
this.compileSource(sources[i]);
}
@ -279,7 +276,7 @@ export class Compiler extends DiagnosticEmitter {
// set up static memory segments and the heap base pointer
if (!options.noMemory) {
var memoryOffset = this.memoryOffset;
let memoryOffset = this.memoryOffset;
memoryOffset = i64_align(memoryOffset, options.usizeType.byteSize);
this.memoryOffset = memoryOffset;
if (options.isWasm64) {
@ -299,7 +296,7 @@ export class Compiler extends DiagnosticEmitter {
}
// determine initial page size
var pages = i64_shr_u(i64_align(memoryOffset, 0x10000), i64_new(16, 0));
let pages = i64_shr_u(i64_align(memoryOffset, 0x10000), i64_new(16, 0));
module.setMemory(
i64_low(pages),
Module.MAX_MEMORY_WASM32, // TODO: not WASM64 compatible yet
@ -316,9 +313,10 @@ export class Compiler extends DiagnosticEmitter {
// set up function table
var functionTable = this.functionTable;
if (k = functionTable.length) {
var entries = new Array<FunctionRef>(k);
for (i = 0; i < k; ++i) {
var functionTableSize = functionTable.length;
if (functionTableSize) {
let entries = new Array<FunctionRef>(functionTableSize);
for (let i = 0; i < functionTableSize; ++i) {
entries[i] = functionTable[i].ref;
}
module.setFunctionTable(entries);
@ -335,7 +333,7 @@ export class Compiler extends DiagnosticEmitter {
// try file.ts
var source: Source;
var expected = normalizedPathWithoutExtension + ".ts";
for (var i = 0, k = sources.length; i < k; ++i) {
for (let i = 0, k = sources.length; i < k; ++i) {
source = sources[i];
if (source.normalizedPath == expected) {
this.compileSource(source);
@ -345,7 +343,7 @@ export class Compiler extends DiagnosticEmitter {
// try file/index.ts
expected = normalizedPathWithoutExtension + "/index.ts";
for (i = 0, k = sources.length; i < k; ++i) {
for (let i = 0, k = sources.length; i < k; ++i) {
source = sources[i];
if (source.normalizedPath == expected) {
this.compileSource(source);
@ -355,7 +353,7 @@ export class Compiler extends DiagnosticEmitter {
// try (lib)/file.ts
expected = LIBRARY_PREFIX + normalizedPathWithoutExtension + ".ts";
for (i = 0, k = sources.length; i < k; ++i) {
for (let i = 0, k = sources.length; i < k; ++i) {
source = sources[i];
if (source.normalizedPath == expected) {
this.compileSource(source);
@ -470,8 +468,8 @@ export class Compiler extends DiagnosticEmitter {
compileGlobalDeclaration(declaration: VariableDeclaration): Global | null {
// look up the initialized program element
var element = this.program.elements.get(declaration.fileLevelInternalName);
if (!element || element.kind != ElementKind.GLOBAL) throw new Error("global expected");
var element = assert(this.program.elements.get(declaration.fileLevelInternalName));
assert(element.kind == ElementKind.GLOBAL);
if (!this.compileGlobal(<Global>element)) return null; // reports
return <Global>element;
}
@ -596,13 +594,12 @@ export class Compiler extends DiagnosticEmitter {
if (initializeInStart) { // initialize to mutable zero and set the actual value in start
this.module.addGlobal(internalName, nativeType, true, global.type.toNativeZero(this.module));
var setExpr = this.module.createSetGlobal(internalName, initExpr);
this.startFunctionBody.push(setExpr);
this.startFunctionBody.push(this.module.createSetGlobal(internalName, initExpr));
} else { // compile as-is
if (global.is(ElementFlags.CONSTANT)) {
var exprType = _BinaryenExpressionGetType(initExpr);
let exprType = _BinaryenExpressionGetType(initExpr);
switch (exprType) {
case NativeType.I32: {
global.constantValueKind = ConstantValueKind.INTEGER;
@ -649,9 +646,10 @@ export class Compiler extends DiagnosticEmitter {
// enums
compileEnumDeclaration(declaration: EnumDeclaration): Enum | null {
var element = this.program.elements.get(declaration.fileLevelInternalName);
if (!element || element.kind != ElementKind.ENUM) throw new Error("enum expected");
return this.compileEnum(<Enum>element) ? <Enum>element : null;
var element = assert(this.program.elements.get(declaration.fileLevelInternalName));
assert(element.kind == ElementKind.ENUM);
if (!this.compileEnum(<Enum>element)) return null;
return <Enum>element;
}
compileEnum(element: Enum): bool {
@ -661,11 +659,11 @@ export class Compiler extends DiagnosticEmitter {
this.currentEnum = element;
var previousValue: EnumValue | null = null;
if (element.members) {
for (var member of element.members.values()) {
for (let member of element.members.values()) {
if (member.kind != ElementKind.ENUMVALUE) continue; // happens if an enum is also a namespace
var initInStart = false;
var val = <EnumValue>member;
var valueDeclaration = val.declaration;
let initInStart = false;
let val = <EnumValue>member;
let valueDeclaration = val.declaration;
val.set(ElementFlags.COMPILED);
if (val.is(ElementFlags.INLINED)) {
if (element.declaration.isTopLevelExport) {
@ -677,7 +675,7 @@ export class Compiler extends DiagnosticEmitter {
);
}
} else {
var initExpr: ExpressionRef;
let initExpr: ExpressionRef;
if (valueDeclaration.value) {
initExpr = this.compileExpression(<Expression>valueDeclaration.value, Type.i32);
if (_BinaryenExpressionGetId(initExpr) != ExpressionId.Const) {
@ -717,8 +715,7 @@ export class Compiler extends DiagnosticEmitter {
true, // mutable
this.module.createI32(0)
);
var setExpr = this.module.createSetGlobal(val.internalName, initExpr);
this.startFunctionBody.push(setExpr);
this.startFunctionBody.push(this.module.createSetGlobal(val.internalName, initExpr));
} else {
this.module.addGlobal(val.internalName, NativeType.I32, false, initExpr);
if (_BinaryenExpressionGetType(initExpr) == NativeType.I32) {
@ -756,10 +753,8 @@ export class Compiler extends DiagnosticEmitter {
typeArguments: TypeNode[],
contextualTypeArguments: Map<string,Type> | null = null
): Function | null {
var element = this.program.elements.get(declaration.fileLevelInternalName);
if (!element || element.kind != ElementKind.FUNCTION_PROTOTYPE) {
throw new Error("function expected");
}
var element = assert(this.program.elements.get(declaration.fileLevelInternalName));
assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);
return this.compileFunctionUsingTypeArguments( // reports
<FunctionPrototype>element,
typeArguments,
@ -780,8 +775,8 @@ export class Compiler extends DiagnosticEmitter {
contextualTypeArguments,
reportNode
);
if (!instance) return null;
return this.compileFunction(instance) ? instance : null;
if (!(instance && this.compileFunction(instance))) return null;
return instance;
}
/** Either reuses or creates the function type matching the specified signature. */
@ -891,8 +886,8 @@ export class Compiler extends DiagnosticEmitter {
compileNamespaceDeclaration(declaration: NamespaceDeclaration): void {
var members = declaration.members;
var noTreeShaking = this.options.noTreeShaking;
for (var i = 0, k = members.length; i < k; ++i) {
var member = members[i];
for (let i = 0, k = members.length; i < k; ++i) {
let member = members[i];
switch (member.kind) {
case NodeKind.CLASSDECLARATION: {
if (
@ -951,7 +946,7 @@ export class Compiler extends DiagnosticEmitter {
noTreeShaking ||
hasModifier(ModifierKind.EXPORT, (<VariableStatement>member).modifiers)
) {
var variableInit = this.compileVariableStatement(<VariableStatement>member, true);
let variableInit = this.compileVariableStatement(<VariableStatement>member, true);
if (variableInit) this.startFunctionBody.push(variableInit);
}
break;
@ -967,7 +962,7 @@ export class Compiler extends DiagnosticEmitter {
if (!ns.members) return;
var noTreeShaking = this.options.noTreeShaking;
for (var element of ns.members.values()) {
for (let element of ns.members.values()) {
switch (element.kind) {
case ElementKind.CLASS_PROTOTYPE: {
if (
@ -1015,14 +1010,14 @@ export class Compiler extends DiagnosticEmitter {
compileExportStatement(statement: ExportStatement): void {
var members = statement.members;
for (var i = 0, k = members.length; i < k; ++i) {
var member = members[i];
var internalExportName = (
for (let i = 0, k = members.length; i < k; ++i) {
let member = members[i];
let internalExportName = (
statement.range.source.internalPath +
PATH_DELIMITER +
member.externalName.text
);
var element = this.program.exports.get(internalExportName);
let element = this.program.exports.get(internalExportName);
if (!element) continue; // reported in Program#initialize
switch (element.kind) {
@ -1041,14 +1036,14 @@ export class Compiler extends DiagnosticEmitter {
!(<FunctionPrototype>element).is(ElementFlags.GENERIC) &&
statement.range.source.isEntry
) {
var functionInstance = this.compileFunctionUsingTypeArguments(
let functionInstance = this.compileFunctionUsingTypeArguments(
<FunctionPrototype>element,
[],
null,
(<FunctionPrototype>element).declaration.name
);
if (functionInstance) {
var functionDeclaration = functionInstance.prototype.declaration;
let functionDeclaration = functionInstance.prototype.declaration;
if (functionDeclaration && functionDeclaration.needsExplicitExport(member)) {
this.module.addFunctionExport(functionInstance.internalName, member.externalName.text);
}
@ -1058,7 +1053,7 @@ export class Compiler extends DiagnosticEmitter {
}
case ElementKind.GLOBAL: {
if (this.compileGlobal(<Global>element) && statement.range.source.isEntry) {
var globalDeclaration = (<Global>element).declaration;
let globalDeclaration = (<Global>element).declaration;
if (globalDeclaration && globalDeclaration.needsExplicitExport(member)) {
if ((<Global>element).is(ElementFlags.INLINED)) {
this.module.addGlobalExport(element.internalName, member.externalName.text);
@ -1238,9 +1233,9 @@ export class Compiler extends DiagnosticEmitter {
}
compileStatements(statements: Statement[]): ExpressionRef[] {
var k = statements.length;
var stmts = new Array<ExpressionRef>(k);
for (var i = 0; i < k; ++i) {
var numStatements = statements.length;
var stmts = new Array<ExpressionRef>(numStatements);
for (let i = 0; i < numStatements; ++i) {
stmts[i] = this.compileStatement(statements[i]);
}
return stmts; // array of 0-es in noEmit-mode
@ -1454,10 +1449,10 @@ export class Compiler extends DiagnosticEmitter {
// introduce a local for evaluating the condition (exactly once)
var tempLocal = this.currentFunction.getTempLocal(Type.u32);
var k = statement.cases.length;
var numCases = statement.cases.length;
// Prepend initializer to inner block. Does not initiate a new branch, yet.
var breaks = new Array<ExpressionRef>(1 + k);
var breaks = new Array<ExpressionRef>(1 + numCases);
breaks[0] = this.module.createSetLocal( // initializer
tempLocal.index,
this.compileExpression(statement.condition, Type.u32)
@ -1466,8 +1461,8 @@ export class Compiler extends DiagnosticEmitter {
// make one br_if per (possibly dynamic) labeled case (binaryen optimizes to br_table where possible)
var breakIndex = 1;
var defaultIndex = -1;
for (var i = 0; i < k; ++i) {
var case_ = statement.cases[i];
for (let i = 0; i < numCases; ++i) {
let case_ = statement.cases[i];
if (case_.label) {
breaks[breakIndex++] = this.module.createBreak("case" + i.toString(10) + "|" + context,
this.module.createBinary(BinaryOp.EqI32,
@ -1491,19 +1486,19 @@ export class Compiler extends DiagnosticEmitter {
// nest blocks in order
var currentBlock = this.module.createBlock("case0|" + context, breaks, NativeType.None);
var alwaysReturns = true;
for (i = 0; i < k; ++i) {
case_ = statement.cases[i];
var l = case_.statements.length;
var body = new Array<ExpressionRef>(1 + l);
for (let i = 0; i < numCases; ++i) {
let case_ = statement.cases[i];
let l = case_.statements.length;
let body = new Array<ExpressionRef>(1 + l);
body[0] = currentBlock;
// Each switch case initiates a new branch
this.currentFunction.flow = this.currentFunction.flow.enterBranchOrScope();
var breakLabel = this.currentFunction.flow.breakLabel = "break|" + context;
let breakLabel = this.currentFunction.flow.breakLabel = "break|" + context;
var fallsThrough = i != k - 1;
var nextLabel = !fallsThrough ? breakLabel : "case" + (i + 1).toString(10) + "|" + context;
for (var j = 0; j < l; ++j) {
let fallsThrough = i != numCases - 1;
let nextLabel = !fallsThrough ? breakLabel : "case" + (i + 1).toString(10) + "|" + context;
for (let j = 0; j < l; ++j) {
body[j + 1] = this.compileStatement(case_.statements[j]);
}
if (!(fallsThrough || this.currentFunction.flow.is(FlowFlags.RETURNS))) {
@ -1549,6 +1544,7 @@ export class Compiler extends DiagnosticEmitter {
*/
compileVariableStatement(statement: VariableStatement, isKnownGlobal: bool = false): ExpressionRef {
var declarations = statement.declarations;
var numDeclarations = declarations.length;
// top-level variables and constants become globals
if (isKnownGlobal || (
@ -1560,7 +1556,7 @@ export class Compiler extends DiagnosticEmitter {
// within any function declared in the same source, which is unknown at this point. the only
// efficient way to deal with this would be to keep track of all occasions it is used and
// replace these instructions afterwards, dynamically. (TOOD: what about a Binaryen pass?)
for (var i = 0, k = declarations.length; i < k; ++i) {
for (let i = 0; i < numDeclarations; ++i) {
this.compileGlobalDeclaration(declarations[i]);
}
return 0;
@ -1568,11 +1564,11 @@ export class Compiler extends DiagnosticEmitter {
// other variables become locals
var initializers = new Array<ExpressionRef>();
for (i = 0, k = declarations.length; i < k; ++i) {
var declaration = declarations[i];
var name = declaration.name.text;
var type: Type | null = null;
var init: ExpressionRef = 0;
for (let i = 0; i < numDeclarations; ++i) {
let declaration = declarations[i];
let name = declaration.name.text;
let type: Type | null = null;
let init: ExpressionRef = 0;
if (declaration.type) {
type = this.program.resolveType( // reports
declaration.type,
@ -1607,7 +1603,7 @@ export class Compiler extends DiagnosticEmitter {
if (init) {
init = this.precomputeExpressionRef(init);
if (_BinaryenExpressionGetId(init) == ExpressionId.Const) {
var local = new Local(this.program, name, -1, type);
let local = new Local(this.program, name, -1, type);
switch (_BinaryenExpressionGetType(init)) {
case NativeType.I32: {
local = local.withConstantIntegerValue(_BinaryenConstGetValueI32(init), 0);
@ -1633,7 +1629,7 @@ export class Compiler extends DiagnosticEmitter {
}
}
// Create a virtual local that doesn't actually exist in WebAssembly
var scopedLocals = this.currentFunction.flow.scopedLocals;
let scopedLocals = this.currentFunction.flow.scopedLocals;
if (!scopedLocals) scopedLocals = this.currentFunction.flow.scopedLocals = new Map();
else if (scopedLocals.has(name)) {
this.error(
@ -4204,12 +4200,12 @@ export class Compiler extends DiagnosticEmitter {
compileCommaExpression(expression: CommaExpression, contextualType: Type): ExpressionRef {
var expressions = expression.expressions;
var k = expressions.length;
var exprs = new Array<ExpressionRef>(k--);
for (var i = 0; i < k; ++i) {
var numExpressions = expressions.length;
var exprs = new Array<ExpressionRef>(numExpressions--);
for (let i = 0; i < numExpressions; ++i) {
exprs[i] = this.compileExpression(expressions[i], Type.void); // drop all
}
exprs[i] = this.compileExpression(expressions[i], contextualType); // except last
exprs[numExpressions] = this.compileExpression(expressions[numExpressions], contextualType); // except last
return this.module.createBlock(null, exprs, this.currentType.toNativeType());
}
@ -4381,7 +4377,7 @@ export class Compiler extends DiagnosticEmitter {
switch (expression.literalKind) {
case LiteralKind.ARRAY: {
assert(!implicitNegate);
var classType = contextualType.classType;
let classType = contextualType.classType;
if (
classType &&
classType == this.program.elements.get("Array") &&
@ -4399,7 +4395,7 @@ export class Compiler extends DiagnosticEmitter {
return this.module.createUnreachable();
}
case LiteralKind.FLOAT: {
var floatValue = (<FloatLiteralExpression>expression).value;
let floatValue = (<FloatLiteralExpression>expression).value;
if (implicitNegate) {
floatValue = -floatValue;
}
@ -4410,7 +4406,7 @@ export class Compiler extends DiagnosticEmitter {
return this.module.createF64(floatValue);
}
case LiteralKind.INTEGER: {
var intValue = (<IntegerLiteralExpression>expression).value;
let intValue = (<IntegerLiteralExpression>expression).value;
if (implicitNegate) {
intValue = i64_sub(
i64_new(0),
@ -4512,13 +4508,13 @@ export class Compiler extends DiagnosticEmitter {
compileStaticString(stringValue: string): ExpressionRef {
var stringSegment: MemorySegment | null = this.stringSegments.get(stringValue);
if (!stringSegment) {
var stringLength = stringValue.length;
var stringBuffer = new Uint8Array(4 + stringLength * 2);
let stringLength = stringValue.length;
let stringBuffer = new Uint8Array(4 + stringLength * 2);
stringBuffer[0] = stringLength & 0xff;
stringBuffer[1] = (stringLength >>> 8) & 0xff;
stringBuffer[2] = (stringLength >>> 16) & 0xff;
stringBuffer[3] = (stringLength >>> 24) & 0xff;
for (var i = 0; i < stringLength; ++i) {
for (let i = 0; i < stringLength; ++i) {
stringBuffer[4 + i * 2] = stringValue.charCodeAt(i) & 0xff;
stringBuffer[5 + i * 2] = (stringValue.charCodeAt(i) >>> 8) & 0xff;
}
@ -4567,7 +4563,7 @@ export class Compiler extends DiagnosticEmitter {
var exprs = new Array<ExpressionRef>(size);
var expr: BinaryenExpressionRef;
for (var i = 0; i < size; ++i) {
for (let i = 0; i < size; ++i) {
exprs[i] = expressions[i]
? this.compileExpression(<Expression>expressions[i], elementType)
: elementType.toNativeZero(this.module);
@ -4623,26 +4619,26 @@ export class Compiler extends DiagnosticEmitter {
);
if (resolved) {
if (resolved.element.kind == ElementKind.CLASS_PROTOTYPE) {
var prototype = <ClassPrototype>resolved.element;
var instance = prototype.resolveUsingTypeArguments( // reports
let prototype = <ClassPrototype>resolved.element;
let instance = prototype.resolveUsingTypeArguments( // reports
expression.typeArguments,
null,
expression
);
if (instance) {
var thisExpr = compileBuiltinAllocate(this, instance, expression);
var initializers = new Array<ExpressionRef>();
let thisExpr = compileBuiltinAllocate(this, instance, expression);
let initializers = new Array<ExpressionRef>();
// use a temp local for 'this'
var tempLocal = this.currentFunction.getTempLocal(this.options.usizeType);
let tempLocal = this.currentFunction.getTempLocal(this.options.usizeType);
initializers.push(this.module.createSetLocal(tempLocal.index, thisExpr));
// apply field initializers
if (instance.members) {
for (var member of instance.members.values()) {
for (let member of instance.members.values()) {
if (member.kind == ElementKind.FIELD) {
var field = <Field>member;
var fieldDeclaration = field.prototype.declaration;
let field = <Field>member;
let fieldDeclaration = field.prototype.declaration;
if (field.is(ElementFlags.CONSTANT)) {
assert(false); // there are no built-in fields currently
} else if (fieldDeclaration && fieldDeclaration.initializer) {
@ -4658,7 +4654,7 @@ export class Compiler extends DiagnosticEmitter {
}
// apply constructor
var constructorInstance = instance.constructorInstance;
let constructorInstance = instance.constructorInstance;
if (constructorInstance) {
initializers.push(this.compileCallDirect(constructorInstance, expression.arguments, expression,
this.module.createGetLocal(tempLocal.index, this.options.nativeSizeType)
@ -4755,9 +4751,9 @@ export class Compiler extends DiagnosticEmitter {
);
}
case ElementKind.PROPERTY: { // instance property (here: getter)
var prototype = (<Property>element).getterPrototype;
let prototype = (<Property>element).getterPrototype;
if (prototype) {
var instance = prototype.resolve(null); // reports
let instance = prototype.resolve(null); // reports
if (!instance) return this.module.createUnreachable();
let signature = instance.signature;
if (!this.checkCallSignature( // reports

2
src/decompiler.ts
View File

@ -37,7 +37,7 @@ export class Decompiler {
this.push("function ");
this.push(name);
this.push("(");
for (var i: Index = 0, k: Index = _BinaryenFunctionGetNumParams(func); i < k; ++i) {
for (let i: Index = 0, k: Index = _BinaryenFunctionGetNumParams(func); i < k; ++i) {
if (i > 0) this.push(", ");
this.push("$");
this.push(i.toString(10));

2
src/diagnostics.ts
View File

@ -150,7 +150,7 @@ export function formatDiagnosticMessage(
// range information if available
if (message.range) {
var range = message.range;
let range = message.range;
if (showContext) {
sb.push("\n");
sb.push(context);

327
src/extra/ast.ts
View File

@ -314,7 +314,7 @@ export function serializeNode(node: Node, sb: string[]): void {
}
export function serializeSource(source: Source, sb: string[]): void {
for (var i = 0, k = source.statements.length; i < k; ++i) {
for (let i = 0, k = source.statements.length; i < k; ++i) {
serializeTerminatedStatement(source.statements[i], sb);
}
}
@ -329,11 +329,11 @@ export function serializeTypeNode(node: CommonTypeNode, sb: string[]): void {
var typeNode = <TypeNode>node;
serializeIdentifierExpression(<IdentifierExpression>typeNode.name, sb);
if (typeNode.typeArguments) {
var k = typeNode.typeArguments.length;
if (k) {
let numTypeArguments = typeNode.typeArguments.length;
if (numTypeArguments) {
sb.push("<");
serializeTypeNode(typeNode.typeArguments[0], sb);
for (var i = 1; i < k; ++i) {
for (let i = 1; i < numTypeArguments; ++i) {
sb.push(", ");
serializeTypeNode(typeNode.typeArguments[i], sb);
}
@ -393,10 +393,10 @@ export function serializeIdentifierExpression(node: IdentifierExpression, sb: st
export function serializeArrayLiteralExpression(node: ArrayLiteralExpression, sb: string[]): void {
sb.push("[");
var elements = node.elementExpressions;
var k = elements.length;
if (k) {
var numElements = elements.length;
if (numElements) {
if (elements[0]) serializeExpression(<Expression>elements[0], sb);
for (var i = 1; i < k; ++i) {
for (let i = 1; i < numElements; ++i) {
sb.push(", ");
if (elements[i]) serializeExpression(<Expression>elements[i], sb);
}
@ -450,11 +450,12 @@ export function serializeCallExpression(node: CallExpression, sb: string[]): voi
}
export function serializeCommaExpression(node: CommaExpression, sb: string[]): void {
var k = assert(node.expressions.length);
serializeExpression(node.expressions[0], sb);
for (var i = 1; i < k; ++i) {
var expressions = node.expressions;
var numExpressions = assert(expressions.length);
serializeExpression(expressions[0], sb);
for (let i = 1; i < numExpressions; ++i) {
sb.push(",");
serializeExpression(node.expressions[i], sb);
serializeExpression(expressions[i], sb);
}
}
@ -525,7 +526,8 @@ export function serializeStringLiteral(str: string, sb: string[], singleQuoted:
var off = 0;
var quote = singleQuoted ? "'" : "\"";
sb.push(quote);
for (var i = 0, k = str.length; i < k;) {
var i = 0;
for (let k = str.length; i < k;) {
switch (str.charCodeAt(i)) {
case CharCode.NULL: {
if (i > off) sb.push(str.substring(off, off = i + 1));
@ -680,7 +682,7 @@ function serializeTerminatedStatement(statement: Statement, sb: string[]): void
) {
sb.push(";\n");
} else {
var last = sb[sb.length - 1];
let last = sb[sb.length - 1];
if (last.length && last.charCodeAt(last.length - 1) == CharCode.CLOSEBRACE) {
sb.push("\n");
} else {
@ -690,71 +692,81 @@ function serializeTerminatedStatement(statement: Statement, sb: string[]): void
}
export function serializeBlockStatement(node: BlockStatement, sb: string[]): void {
var statements = node.statements;
sb.push("{\n");
for (var i = 0, k = node.statements.length; i < k; ++i) {
serializeTerminatedStatement(node.statements[i], sb);
for (let i = 0, k = statements.length; i < k; ++i) {
serializeTerminatedStatement(statements[i], sb);
}
sb.push("}");
}
export function serializeBreakStatement(node: BreakStatement, sb: string[]): void {
if (node.label) {
var label = node.label;
if (label) {
sb.push("break ");
serializeIdentifierExpression(node.label, sb);
serializeIdentifierExpression(label, sb);
} else {
sb.push("break");
}
}
export function serializeContinueStatement(node: ContinueStatement, sb: string[]): void {
if (node.label) {
var label = node.label;
if (label) {
sb.push("continue ");
serializeIdentifierExpression(node.label, sb);
serializeIdentifierExpression(label, sb);
} else {
sb.push("continue");
}
}
export function serializeClassDeclaration(node: ClassDeclaration, sb: string[]): void {
var i: i32, k: i32;
if (node.decorators) {
for (i = 0, k = node.decorators.length; i < k; ++i) {
serializeDecorator(node.decorators[i], sb);
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
serializeDecorator(decorators[i], sb);
sb.push("\n");
}
}
if (node.modifiers) {
for (i = 0, k = node.modifiers.length; i < k; ++i) {
serializeModifier(node.modifiers[i], sb);
var modifiers = node.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
serializeModifier(modifiers[i], sb);
sb.push(" ");
}
}
sb.push("class ");
serializeIdentifierExpression(node.name, sb);
if (k = node.typeParameters.length) {
var typeParameters = node.typeParameters;
var numTypeParameters = typeParameters.length;
if (numTypeParameters) {
sb.push("<");
serializeTypeParameter(node.typeParameters[0], sb);
for (i = 1; i < k; ++i) {
serializeTypeParameter(typeParameters[0], sb);
for (let i = 1; i < numTypeParameters; ++i) {
sb.push(", ");
serializeTypeParameter(node.typeParameters[i], sb);
}
sb.push(">");
}
if (node.extendsType) {
var extendsType = node.extendsType;
if (extendsType) {
sb.push(" extends ");
serializeTypeNode(node.extendsType, sb);
serializeTypeNode(extendsType, sb);
}
if (k = node.implementsTypes.length) {
var implementsTypes = node.implementsTypes;
var numImplementsTypes = implementsTypes.length;
if (numImplementsTypes) {
sb.push(" implements ");
serializeTypeNode(node.implementsTypes[0], sb);
for (i = 1; i < k; ++i) {
serializeTypeNode(implementsTypes[0], sb);
for (let i = 1; i < numImplementsTypes; ++i) {
sb.push(", ");
serializeTypeNode(node.implementsTypes[i], sb);
serializeTypeNode(implementsTypes[i], sb);
}
}
sb.push(" {\n");
for (i = 0, k = node.members.length; i < k; ++i) {
serializeTerminatedStatement(node.members[i], sb);
var members = node.members;
for (let i = 0, k = members.length; i < k; ++i) {
serializeTerminatedStatement(members[i], sb);
}
sb.push("}");
}
@ -975,98 +987,110 @@ export function serializeIfStatement(node: IfStatement, sb: string[]): void {
sb.push("if (");
serializeExpression(node.condition, sb);
sb.push(") ");
serializeStatement(node.ifTrue, sb);
if (node.ifTrue.kind != NodeKind.BLOCK) {
var ifTrue = node.ifTrue;
serializeStatement(ifTrue, sb);
if (ifTrue.kind != NodeKind.BLOCK) {
sb.push(";\n");
}
if (node.ifFalse) {
if (node.ifTrue.kind == NodeKind.BLOCK) {
var ifFalse = node.ifFalse;
if (ifFalse) {
if (ifTrue.kind == NodeKind.BLOCK) {
sb.push(" else ");
} else {
sb.push("else ");
}
serializeStatement(node.ifFalse, sb);
serializeStatement(ifFalse, sb);
}
}
export function serializeImportDeclaration(node: ImportDeclaration, sb: string[]): void {
serializeIdentifierExpression(node.externalName, sb);
if (node.externalName.text != node.name.text) {
var externalName = node.externalName;
var name = node.name;
serializeIdentifierExpression(externalName, sb);
if (externalName.text != name.text) {
sb.push(" as ");
serializeIdentifierExpression(node.name, sb);
serializeIdentifierExpression(name, sb);
}
}
export function serializeImportStatement(node: ImportStatement, sb: string[]): void {
sb.push("import ");
if (node.declarations) {
var k = node.declarations.length;
if (k) {
var declarations = node.declarations;
var namespaceName = node.namespaceName;
if (declarations) {
let numDeclarations = declarations.length;
if (numDeclarations) {
sb.push("{\n");
serializeImportDeclaration(node.declarations[0], sb);
for (var i = 1; i < k; ++i) {
serializeImportDeclaration(declarations[0], sb);
for (let i = 1; i < numDeclarations; ++i) {
sb.push(",\n");
serializeImportDeclaration(node.declarations[i], sb);
serializeImportDeclaration(declarations[i], sb);
}
sb.push("\n} from ");
} else {
sb.push("{} from ");
}
} else if (node.namespaceName) {
} else if (namespaceName) {
sb.push("* as ");
serializeIdentifierExpression(node.namespaceName, sb);
serializeIdentifierExpression(namespaceName, sb);
sb.push(" from ");
}
serializeStringLiteralExpression(node.path, sb);
}
export function serializeInterfaceDeclaration(node: InterfaceDeclaration, sb: string[]): void {
var i: i32, k: i32;
if (node.decorators) {
for (i = 0, k = node.decorators.length; i < k; ++i) {
serializeDecorator(node.decorators[i], sb);
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
serializeDecorator(decorators[i], sb);
sb.push("\n");
}
}
if (node.modifiers) {
for (i = 0, k = node.modifiers.length; i < k; ++i) {
serializeModifier(node.modifiers[i], sb);
var modifiers = node.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
serializeModifier(modifiers[i], sb);
sb.push(" ");
}
}
sb.push("interface ");
serializeIdentifierExpression(node.name, sb);
if (k = node.typeParameters.length) {
var typeParameters = node.typeParameters;
var numTypeParameters = typeParameters.length;
if (numTypeParameters) {
sb.push("<");
serializeTypeParameter(node.typeParameters[0], sb);
for (i = 0; i < k; ++i) {
for (let i = 0; i < numTypeParameters; ++i) {
sb.push(", ");
serializeTypeParameter(node.typeParameters[i], sb);
}
sb.push(">");
}
if (node.extendsType) {
var extendsType = node.extendsType;
if (extendsType) {
sb.push(" extends ");
serializeTypeNode(node.extendsType, sb);
serializeTypeNode(extendsType, sb);
}
sb.push(" {\n");
for (i = 0, k = node.members.length; i < k; ++i) {
serializeTerminatedStatement(node.members[i], sb);
var members = node.members;
for (let i = 0, k = members.length; i < k; ++i) {
serializeTerminatedStatement(members[i], sb);
}
sb.push("}");
}
export function serializeMethodDeclaration(node: MethodDeclaration, sb: string[]): void {
var i: i32, k: i32;
if (node.decorators) {
for (i = 0, k = node.decorators.length; i < k; ++i) {
serializeDecorator(node.decorators[i], sb);
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
serializeDecorator(decorators[i], sb);
sb.push("\n");
}
}
if (node.modifiers) {
for (i = 0, k = node.modifiers.length; i < k; ++i) {
serializeModifier(node.modifiers[i], sb);
var modifiers = node.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
serializeModifier(modifiers[i], sb);
sb.push(" ");
}
}
@ -1074,51 +1098,56 @@ export function serializeMethodDeclaration(node: MethodDeclaration, sb: string[]
}
export function serializeNamespaceDeclaration(node: NamespaceDeclaration, sb: string[]): void {
var i: i32, k: i32;
if (node.decorators) {
for (i = 0, k = node.decorators.length; i < k; ++i) {
serializeDecorator(node.decorators[i], sb);
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
serializeDecorator(decorators[i], sb);
sb.push("\n");
}
}
if (node.modifiers) {
for (i = 0, k = node.modifiers.length; i < k; ++i) {
serializeModifier(node.modifiers[i], sb);
var modifiers = node.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
serializeModifier(modifiers[i], sb);
sb.push(" ");
}
}
sb.push("namespace ");
serializeIdentifierExpression(node.name, sb);
sb.push(" {\n");
for (i = 0, k = node.members.length; i < k; ++i) {
serializeTerminatedStatement(node.members[i], sb);
var members = node.members;
for (let i = 0, k = members.length; i < k; ++i) {
serializeTerminatedStatement(members[i], sb);
}
sb.push("}");
}
export function serializeReturnStatement(node: ReturnStatement, sb: string[]): void {
if (node.value) {
var value = node.value;
if (value) {
sb.push("return ");
serializeExpression(node.value, sb);
serializeExpression(value, sb);
} else {
sb.push("return");
}
}
export function serializeSwitchCase(node: SwitchCase, sb: string[]): void {
if (node.label) {
var label = node.label;
if (label) {
sb.push("case ");
serializeExpression(node.label, sb);
serializeExpression(label, sb);
sb.push(":\n");
} else {
sb.push("default:\n");
}
var k = node.statements.length;
if (k) {
serializeTerminatedStatement(node.statements[0], sb);
for (var i = 1; i < k; ++i) {
var statements = node.statements;
var numStatements = statements.length;
if (numStatements) {
serializeTerminatedStatement(statements[0], sb);
for (let i = 1; i < numStatements; ++i) {
sb.push("\n");
serializeTerminatedStatement(node.statements[i], sb);
serializeTerminatedStatement(statements[i], sb);
}
}
}
@ -1127,8 +1156,9 @@ export function serializeSwitchStatement(node: SwitchStatement, sb: string[]): v
sb.push("switch (");
serializeExpression(node.condition, sb);
sb.push(") {\n");
for (var i = 0, k = node.cases.length; i < k; ++i) {
serializeSwitchCase(node.cases[i], sb);
var cases = node.cases;
for (let i = 0, k = cases.length; i < k; ++i) {
serializeSwitchCase(cases[i], sb);
sb.push("\n");
}
sb.push("}");
@ -1141,27 +1171,30 @@ export function serializeThrowStatement(node: ThrowStatement, sb: string[]): voi
}
export function serializeTryStatement(node: TryStatement, sb: string[]): void {
var i: i32, k: i32;
sb.push("try {\n");
for (i = 0, k = node.statements.length; i < k; ++i) {
serializeStatement(node.statements[i], sb);
var statements = node.statements;
for (let i = 0, k = statements.length; i < k; ++i) {
serializeStatement(statements[i], sb);
sb.push(";\n");
}
if (node.catchVariable) {
var catchVariable = node.catchVariable;
if (catchVariable) {
sb.push("} catch (");
serializeIdentifierExpression(node.catchVariable, sb);
serializeIdentifierExpression(catchVariable, sb);
sb.push(") {\n");
if (node.catchStatements) {
for (i = 0, k = node.catchStatements.length; i < k; ++i) {
serializeStatement(node.catchStatements[i], sb);
let catchStatements = node.catchStatements;
if (catchStatements) {
for (let i = 0, k = catchStatements.length; i < k; ++i) {
serializeStatement(catchStatements[i], sb);
sb.push(";\n");
}
}
}
if (node.finallyStatements) {
var finallyStatements = node.finallyStatements;
if (finallyStatements) {
sb.push("} finally {\n");
for (i = 0, k = node.finallyStatements.length; i < k; ++i) {
serializeStatement(node.finallyStatements[i], sb);
for (let i = 0, k = finallyStatements.length; i < k; ++i) {
serializeStatement(finallyStatements[i], sb);
sb.push(";\n");
}
}
@ -1169,28 +1202,32 @@ export function serializeTryStatement(node: TryStatement, sb: string[]): void {
}
export function serializeTypeDeclaration(node: TypeDeclaration, sb: string[]): void {
var i: i32, k: i32;
if (node.decorators) {
for (i = 0, k = node.decorators.length; i < k; ++i) {
serializeDecorator(node.decorators[i], sb);
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
serializeDecorator(decorators[i], sb);
sb.push("\n");
}
}
if (node.modifiers) {
for (i = 0, k = node.modifiers.length; i < k; ++i) {
serializeModifier(node.modifiers[i], sb);
var modifiers = node.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
serializeModifier(modifiers[i], sb);
sb.push(" ");
}
}
sb.push("type ");
serializeIdentifierExpression(node.name, sb);
var typeParameters = node.typeParameters;
if (typeParameters && (k = typeParameters.length)) {
sb.push("<");
for (i = 0; i < k; ++i) {
serializeTypeParameter(typeParameters[i], sb);
if (typeParameters) {
let numTypeParameters = typeParameters.length;
if (numTypeParameters) {
sb.push("<");
for (let i = 0; i < numTypeParameters; ++i) {
serializeTypeParameter(typeParameters[i], sb);
}
sb.push(">");
}
sb.push(">");
}
sb.push(" = ");
serializeTypeNode(node.type, sb);
@ -1198,28 +1235,31 @@ export function serializeTypeDeclaration(node: TypeDeclaration, sb: string[]): v
export function serializeVariableDeclaration(node: VariableDeclaration, sb: string[]): void {
serializeIdentifierExpression(node.name, sb);
if (node.type) {
var type = node.type;
if (type) {
sb.push(": ");
serializeTypeNode(node.type, sb);
serializeTypeNode(type, sb);
}
if (node.initializer) {
var initializer = node.initializer;
if (initializer) {
sb.push(" = ");
serializeExpression(node.initializer, sb);
serializeExpression(initializer, sb);
}
}
export function serializeVariableStatement(node: VariableStatement, sb: string[]): void {
var i: i32, k: i32;
if (node.decorators) {
for (i = 0, k = node.decorators.length; i < k; ++i) {
serializeDecorator(node.decorators[i], sb);
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
serializeDecorator(decorators[i], sb);
sb.push("\n");
}
}
var isConst = false, isLet = false;
if (node.modifiers) {
for (i = 0, k = node.modifiers.length; i < k; ++i) {
var modifier = node.modifiers[i];
var modifiers = node.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
let modifier = modifiers[i];
switch (modifier.modifierKind) {
case ModifierKind.CONST: {
assert(!isLet);
@ -1240,9 +1280,10 @@ export function serializeVariableStatement(node: VariableStatement, sb: string[]
}
}
sb.push(isConst ? "const " : isLet ? "let " : "var ");
k = assert(node.declarations.length);
var declarations = node.declarations;
var numDeclarations = assert(declarations.length);
serializeVariableDeclaration(node.declarations[0], sb);
for (i = 1; i < k; ++i) {
for (let i = 1; i < numDeclarations; ++i) {
sb.push(", ");
serializeVariableDeclaration(node.declarations[i], sb);
}
@ -1260,14 +1301,15 @@ export function serializeWhileStatement(node: WhileStatement, sb: string[]): voi
export function serializeDecorator(node: DecoratorNode, sb: string[]): void {
sb.push("@");
serializeExpression(node.name, sb);
if (node.arguments) {
var args = node.arguments;
if (args) {
sb.push("(");
var k = node.arguments.length;
if (k) {
serializeExpression(node.arguments[0], sb);
for (var i = 1; i < k; ++i) {
let numArgs = args.length;
if (numArgs) {
serializeExpression(args[0], sb);
for (let i = 1; i < numArgs; ++i) {
sb.push(", ");
serializeExpression(node.arguments[i], sb);
serializeExpression(args[i], sb);
}
}
sb.push(")");
@ -1279,21 +1321,24 @@ export function serializeModifier(node: ModifierNode, sb: string[]): void {
}
export function serializeParameter(node: ParameterNode, sb: string[]): void {
if (node.parameterKind == ParameterKind.REST) {
var kind = node.parameterKind;
if (kind == ParameterKind.REST) {
sb.push("...");
}
serializeIdentifierExpression(node.name, sb);
if (node.type) {
if (node.parameterKind == ParameterKind.OPTIONAL && !node.initializer) {
var type = node.type;
var initializer = node.initializer;
if (type) {
if (kind == ParameterKind.OPTIONAL && !initializer) {
sb.push("?: ");
} else {
sb.push(": ");
}
serializeTypeNode(node.type, sb);
serializeTypeNode(type, sb);
}
if (node.initializer) {
if (initializer) {
sb.push(" = ");
serializeExpression(node.initializer, sb);
serializeExpression(initializer, sb);
}
}

62
src/module.ts
View File

@ -249,10 +249,10 @@ export class Module {
static createFrom(buffer: Uint8Array): Module {
var cArr = allocU8Array(buffer);
try {
var module = new Module();
let module = new Module();
module.ref = _BinaryenModuleRead(cArr, buffer.length);
module.out = allocate_memory(3 * 8); // LLVM C-ABI, max used is 3 * usize
return module;
return module;
} finally {
free_memory(changetype<usize>(cArr));
}
@ -549,18 +549,19 @@ export class Module {
condition: ExpressionRef,
value: ExpressionRef = 0
): ExpressionRef {
var strs = new Array<usize>(names.length);
for (var i = 0, k: i32 = names.length; i < k; ++i) {
var numNames = names.length;
var strs = new Array<usize>(numNames);
for (let i = 0; i < numNames; ++i) {
strs[i] = allocString(names[i]);
}
var cArr = allocI32Array(strs);
var cStr = allocString(defaultName);
try {
return _BinaryenSwitch(this.ref, cArr, k, cStr, condition, value);
return _BinaryenSwitch(this.ref, cArr, numNames, cStr, condition, value);
} finally {
free_memory(cStr);
free_memory(cArr);
for (i = k - 1; i >= 0; --i) free_memory(strs[i]);
for (let i = numNames - 1; i >= 0; --i) free_memory(strs[i]);
}
}
@ -810,9 +811,9 @@ export class Module {
var segs = new Array<usize>(k);
var offs = new Array<ExpressionRef>(k);
var sizs = new Array<Index>(k);
for (var i = 0; i < k; ++i) {
var buffer = segments[i].buffer;
var offset = segments[i].offset;
for (let i = 0; i < k; ++i) {
let buffer = segments[i].buffer;
let offset = segments[i].offset;
segs[i] = allocU8Array(buffer);
offs[i] = target == Target.WASM64
? this.createI64(i64_low(offset), i64_high(offset))
@ -828,7 +829,7 @@ export class Module {
free_memory(cArr3);
free_memory(cArr2);
free_memory(cArr1);
for (i = k - 1; i >= 0; --i) free_memory(segs[i]);
for (let i = k - 1; i >= 0; --i) free_memory(segs[i]);
free_memory(cStr);
}
}
@ -867,21 +868,23 @@ export class Module {
}
runPasses(passes: string[], func: FunctionRef = 0): void {
var k = passes.length;
var names = new Array<usize>(k);
for (var i = 0; i < k; ++i) {
var numNames = passes.length;
var names = new Array<usize>(numNames);
for (let i = 0; i < numNames; ++i) {
names[i] = allocString(passes[i]);
}
var cArr = allocI32Array(names);
try {
if (func) {
_BinaryenFunctionRunPasses(func, this.ref, cArr, k);
_BinaryenFunctionRunPasses(func, this.ref, cArr, numNames);
} else {
_BinaryenModuleRunPasses(this.ref, cArr, k);
_BinaryenModuleRunPasses(this.ref, cArr, numNames);
}
} finally {
free_memory(cArr);
for (; i >= 0; --i) free_memory(names[i]);
for (let i = numNames; i >= 0; --i) {
free_memory(names[i]);
}
}
}
@ -900,10 +903,10 @@ export class Module {
var sourceMapPtr: usize = 0;
try {
_BinaryenModuleAllocateAndWrite(out, this.ref, cStr);
binaryPtr = readInt(out);
var binaryBytes = readInt(out + 4);
binaryPtr = readInt(out);
let binaryBytes = readInt(out + 4);
sourceMapPtr = readInt(out + 4 * 2);
var ret = new Binary();
let ret = new Binary();
ret.output = readBuffer(binaryPtr, binaryBytes);
ret.sourceMap = readString(sourceMapPtr);
return ret;
@ -972,7 +975,7 @@ export class Module {
);
}
case ExpressionId.GetGlobal: {
var globalName = _BinaryenGetGlobalGetName(expr);
let globalName = _BinaryenGetGlobalGetName(expr);
if (!globalName) break;
return _BinaryenGetGlobal(this.ref, globalName, _BinaryenExpressionGetType(expr));
}
@ -1093,9 +1096,10 @@ export class Relooper {
function allocU8Array(u8s: Uint8Array | null): usize {
if (!u8s) return 0;
var ptr = allocate_memory(u8s.length);
var numValues = u8s.length;
var ptr = allocate_memory(numValues);
var idx = ptr;
for (var i = 0, k = u8s.length; i < k; ++i) {
for (let i = 0; i < numValues; ++i) {
store<u8>(idx++, u8s[i]);
}
return ptr;
@ -1105,8 +1109,8 @@ function allocI32Array(i32s: i32[] | null): usize {
if (!i32s) return 0;
var ptr = allocate_memory(i32s.length << 2);
var idx = ptr;
for (var i = 0, k = i32s.length; i < k; ++i) {
var val = i32s[i];
for (let i = 0, k = i32s.length; i < k; ++i) {
let val = i32s[i];
// store<i32>(idx, val) is not portable
store<u8>(idx , ( val & 0xff) as u8);
store<u8>(idx + 1, ((val >> 8) & 0xff) as u8);
@ -1119,8 +1123,8 @@ function allocI32Array(i32s: i32[] | null): usize {
function stringLengthUTF8(str: string): usize {
var len = 0;
for (var i = 0, k = str.length; i < k; ++i) {
var u = str.charCodeAt(i);
for (let i = 0, k = str.length; i < k; ++i) {
let u = str.charCodeAt(i);
if (u >= 0xD800 && u <= 0xDFFF && i + 1 < k) {
u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);
}
@ -1145,8 +1149,8 @@ function allocString(str: string | null): usize {
if (str == null) return 0;
var ptr = allocate_memory(stringLengthUTF8(str) + 1);
var idx = ptr;
for (var i = 0, k = str.length; i < k; ++i) {
var u = str.charCodeAt(i);
for (let i = 0, k = str.length; i < k; ++i) {
let u = str.charCodeAt(i);
if (u >= 0xD800 && u <= 0xDFFF && i + 1 < k) {
u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);
}
@ -1194,7 +1198,7 @@ export function readInt(ptr: usize): i32 {
export function readBuffer(ptr: usize, length: usize): Uint8Array {
var ret = new Uint8Array(length);
for (var i: usize = 0; i < length; ++i) {
for (let i: usize = 0; i < length; ++i) {
ret[i] = load<u8>(ptr + i);
}
return ret;

220
src/parser.ts
View File

@ -109,11 +109,13 @@ export class Parser extends DiagnosticEmitter {
path: string,
isEntry: bool
): void {
var program = this.program;
// check if already parsed
var normalizedPath = normalizePath(path);
for (var i = 0, k = this.program.sources.length; i < k; ++i) {
if (this.program.sources[i].normalizedPath == normalizedPath) return;
var sources = program.sources;
for (let i = 0, k = sources.length; i < k; ++i) {
if (sources[i].normalizedPath == normalizedPath) return;
}
this.seenlog.add(normalizedPath);
@ -127,13 +129,13 @@ export class Parser extends DiagnosticEmitter {
? SourceKind.LIBRARY
: SourceKind.DEFAULT
);
this.program.sources.push(source);
sources.push(source);
// tokenize and parse
var tn = new Tokenizer(source, this.program.diagnostics);
var tn = new Tokenizer(source, program.diagnostics);
source.tokenizer = tn;
while (!tn.skip(Token.ENDOFFILE)) {
var statement = this.parseTopLevelStatement(tn);
let statement = this.parseTopLevelStatement(tn);
if (statement) {
statement.parent = source;
source.statements.push(statement);
@ -151,7 +153,7 @@ export class Parser extends DiagnosticEmitter {
// check decorators
var decorators: DecoratorNode[] | null = null;
while (tn.skip(Token.AT)) {
var decorator = this.parseDecorator(tn);
let decorator = this.parseDecorator(tn);
if (!decorator) break;
if (!decorators) decorators = [];
decorators.push(decorator);
@ -282,7 +284,7 @@ export class Parser extends DiagnosticEmitter {
// check for decorators that weren't consumed
if (decorators) {
for (var i = 0, k = decorators.length; i < k; ++i) {
for (let i = 0, k = decorators.length; i < k; ++i) {
this.error(
DiagnosticCode.Decorators_are_not_valid_here,
decorators[i].range
@ -411,14 +413,14 @@ export class Parser extends DiagnosticEmitter {
// Identifier
} else if (token == Token.IDENTIFIER) {
var identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
var parameters = new Array<TypeNode>();
var nullable = false;
let identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
let parameters = new Array<TypeNode>();
let nullable = false;
// Name<T>
if (tn.skip(Token.LESSTHAN)) {
do {
var parameter = this.parseType(tn, true, suppressErrors);
let parameter = this.parseType(tn, true, suppressErrors);
if (!parameter) return null;
parameters.push(<TypeNode>parameter);
} while (tn.skip(Token.COMMA));
@ -459,7 +461,7 @@ export class Parser extends DiagnosticEmitter {
}
// ... [][]
while (tn.skip(Token.OPENBRACKET)) {
var bracketStart = tn.tokenPos;
let bracketStart = tn.tokenPos;
if (!tn.skip(Token.CLOSEBRACKET)) {
if (!suppressErrors) {
this.error(
@ -469,10 +471,10 @@ export class Parser extends DiagnosticEmitter {
}
return null;
}
var bracketRange = tn.range(bracketStart, tn.pos);
let bracketRange = tn.range(bracketStart, tn.pos);
// ...[] | null
nullable = false;
let nullable = false;
if (tn.skip(Token.BAR)) {
if (tn.skip(Token.NULL)) {
nullable = true;
@ -522,7 +524,7 @@ export class Parser extends DiagnosticEmitter {
} else {
isSignature = false; // not yet known
do {
var kind = ParameterKind.DEFAULT;
let kind = ParameterKind.DEFAULT;
if (tn.skip(Token.DOT_DOT_DOT)) {
isSignature = true;
tn.discard(state);
@ -549,7 +551,7 @@ export class Parser extends DiagnosticEmitter {
return null;
}
} else if (tn.skip(Token.IDENTIFIER)) {
var name = Node.createIdentifierExpression(tn.readIdentifier(), tn.range(tn.tokenPos, tn.pos));
let name = Node.createIdentifierExpression(tn.readIdentifier(), tn.range(tn.tokenPos, tn.pos));
if (tn.skip(Token.QUESTION)) {
isSignature = true;
tn.discard(state);
@ -565,12 +567,12 @@ export class Parser extends DiagnosticEmitter {
if (tn.skip(Token.COLON)) {
isSignature = true;
tn.discard(state);
var type = this.parseType(tn); // not suppressing errors because known
let type = this.parseType(tn); // not suppressing errors because known
if (!type) {
this.tryParseSignatureIsSignature = isSignature;
return null;
}
var param = new ParameterNode();
let param = new ParameterNode();
param.parameterKind = kind;
param.name = name;
param.type = type;
@ -648,8 +650,8 @@ export class Parser extends DiagnosticEmitter {
var startPos = tn.tokenPos;
if (tn.skip(Token.IDENTIFIER)) {
var name = tn.readIdentifier();
var expression: Expression = Node.createIdentifierExpression(name, tn.range(startPos, tn.pos));
let name = tn.readIdentifier();
let expression: Expression = Node.createIdentifierExpression(name, tn.range(startPos, tn.pos));
while (tn.skip(Token.DOT)) {
if (tn.skip(Token.IDENTIFIER)) {
name = tn.readIdentifier();
@ -666,7 +668,7 @@ export class Parser extends DiagnosticEmitter {
return null;
}
}
var args: Expression[] | null;
let args: Expression[] | null;
if (tn.skip(Token.OPENPAREN)) {
args = this.parseArguments(tn);
if (args) {
@ -696,7 +698,7 @@ export class Parser extends DiagnosticEmitter {
var members = new Array<VariableDeclaration>();
var isDeclare = hasModifier(ModifierKind.DECLARE, modifiers);
do {
var member = this.parseVariableDeclaration(tn, isDeclare, modifiers, decorators);
let member = this.parseVariableDeclaration(tn, isDeclare, modifiers, decorators);
if (!member) return null;
members.push(<VariableDeclaration>member);
} while (tn.skip(Token.COMMA));
@ -791,7 +793,7 @@ export class Parser extends DiagnosticEmitter {
var members = new Array<EnumValueDeclaration>();
if (!tn.skip(Token.CLOSEBRACE)) {
do {
var member = this.parseEnumValue(tn);
let member = this.parseEnumValue(tn);
if (!member) return null;
members.push(<EnumValueDeclaration>member);
} while (tn.skip(Token.COMMA));
@ -869,7 +871,7 @@ export class Parser extends DiagnosticEmitter {
var typeParameters = new Array<TypeParameterNode>();
if (!tn.skip(Token.GREATERTHAN)) {
do {
var typeParameter = this.parseTypeParameter(tn);
let typeParameter = this.parseTypeParameter(tn);
if (!typeParameter) return null;
typeParameters.push(<TypeParameterNode>typeParameter);
} while (tn.skip(Token.COMMA));
@ -896,11 +898,11 @@ export class Parser extends DiagnosticEmitter {
// before: Identifier ('extends' Type)?
if (tn.next() == Token.IDENTIFIER) {
var identifier = Node.createIdentifierExpression(
let identifier = Node.createIdentifierExpression(
tn.readIdentifier(),
tn.range()
);
var extendsType: TypeNode | null = null;
let extendsType: TypeNode | null = null;
if (tn.skip(Token.EXTENDS)) {
let t = this.parseType(tn);
if (!t) return null;
@ -940,7 +942,7 @@ export class Parser extends DiagnosticEmitter {
if (tn.peek() != Token.CLOSEPAREN) {
do {
var param = this.parseParameter(tn);
let param = this.parseParameter(tn);
if (!param) return null;
if (seenRest && !reportedRest) {
this.error(
@ -997,8 +999,8 @@ export class Parser extends DiagnosticEmitter {
}
if (tn.skip(Token.IDENTIFIER)) {
if (!isRest) startRange = tn.range();
var identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
var type: CommonTypeNode | null = null;
let identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
let type: CommonTypeNode | null = null;
if (isOptional = tn.skip(Token.QUESTION)) {
if (isRest) {
this.error(
@ -1011,7 +1013,7 @@ export class Parser extends DiagnosticEmitter {
type = this.parseType(tn);
if (!type) return null;
}
var initializer: Expression | null = null;
let initializer: Expression | null = null;
if (tn.skip(Token.EQUALS)) {
if (isRest) {
this.error(
@ -1315,12 +1317,12 @@ export class Parser extends DiagnosticEmitter {
if (tn.skip(Token.IDENTIFIER)) {
var identifier = Node.createIdentifierExpression(
let identifier = Node.createIdentifierExpression(
tn.readIdentifier(),
tn.range()
);
var typeParameters: TypeParameterNode[] | null;
let typeParameters: TypeParameterNode[] | null;
if (tn.skip(Token.LESSTHAN)) {
typeParameters = this.parseTypeParameters(tn);
if (!typeParameters) return null;
@ -1328,7 +1330,7 @@ export class Parser extends DiagnosticEmitter {
typeParameters = [];
}
var extendsType: TypeNode | null = null;
let extendsType: TypeNode | null = null;
if (tn.skip(Token.EXTENDS)) {
let t = this.parseType(tn);
if (!t) return null;
@ -1342,10 +1344,10 @@ export class Parser extends DiagnosticEmitter {
extendsType = <TypeNode>t;
}
var implementsTypes = new Array<TypeNode>();
let implementsTypes = new Array<TypeNode>();
if (tn.skip(Token.IMPLEMENTS)) {
do {
var type = this.parseType(tn);
let type = this.parseType(tn);
if (!type) return null;
implementsTypes.push(<TypeNode>type);
} while (tn.skip(Token.COMMA));
@ -1353,11 +1355,11 @@ export class Parser extends DiagnosticEmitter {
if (tn.skip(Token.OPENBRACE)) {
var members = new Array<DeclarationStatement>();
let members = new Array<DeclarationStatement>();
if (!tn.skip(Token.CLOSEBRACE)) {
var isDeclare = hasModifier(ModifierKind.DECLARE, modifiers);
let isDeclare = hasModifier(ModifierKind.DECLARE, modifiers);
do {
var member = this.parseClassMember(tn, isDeclare);
let member = this.parseClassMember(tn, isDeclare);
if (!member) return null;
members.push(<DeclarationStatement>member);
} while (!tn.skip(Token.CLOSEBRACE));
@ -1403,7 +1405,7 @@ export class Parser extends DiagnosticEmitter {
var decorators = new Array<DecoratorNode>();
while (tn.skip(Token.AT)) {
var decorator = this.parseDecorator(tn);
let decorator = this.parseDecorator(tn);
if (!decorator) break;
decorators.push(<DecoratorNode>decorator);
}
@ -1454,11 +1456,11 @@ export class Parser extends DiagnosticEmitter {
var isConstructor = tn.skip(Token.CONSTRUCTOR);
if (isConstructor || tn.skip(Token.IDENTIFIER)) {
var name = isConstructor
let name = isConstructor
? Node.createConstructorExpression(tn.range())
: Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
var typeParameters: TypeParameterNode[] | null = null;
let typeParameters: TypeParameterNode[] | null = null;
if (tn.skip(Token.LESSTHAN)) {
if (isConstructor) {
this.error(
@ -1472,8 +1474,8 @@ export class Parser extends DiagnosticEmitter {
// method: '(' Parameters (':' Type)? '{' Statement* '}' ';'?
if (tn.skip(Token.OPENPAREN)) {
var signatureStart = tn.tokenPos;
var parameters = this.parseParameters(tn);
let signatureStart = tn.tokenPos;
let parameters = this.parseParameters(tn);
if (!parameters) return null;
if (isGetter && parameters.length) {
@ -1498,7 +1500,7 @@ export class Parser extends DiagnosticEmitter {
}
}
var returnType: CommonTypeNode | null = null;
let returnType: CommonTypeNode | null = null;
if (tn.skip(Token.COLON)) {
if (name.kind == NodeKind.CONSTRUCTOR) {
this.error(
@ -1523,7 +1525,7 @@ export class Parser extends DiagnosticEmitter {
}
}
var signature = Node.createSignature(
let signature = Node.createSignature(
parameters,
returnType,
null,
@ -1531,7 +1533,7 @@ export class Parser extends DiagnosticEmitter {
tn.range(signatureStart, tn.pos)
);
var body: Statement | null = null;
let body: Statement | null = null;
if (tn.skip(Token.OPENBRACE)) {
if (parentIsDeclare) {
this.error(
@ -1548,7 +1550,7 @@ export class Parser extends DiagnosticEmitter {
); // recoverable
}
var retMethod = Node.createMethodDeclaration(
let retMethod = Node.createMethodDeclaration(
name,
typeParameters,
signature,
@ -1574,7 +1576,7 @@ export class Parser extends DiagnosticEmitter {
// field: (':' Type)? ('=' Expression)? ';'?
} else {
var modifier: ModifierNode | null;
let modifier: ModifierNode | null;
if (modifier = getModifier(ModifierKind.ABSTRACT, modifiers)) {
this.error(
@ -1597,7 +1599,7 @@ export class Parser extends DiagnosticEmitter {
); // recoverable
}
var type: CommonTypeNode | null = null;
let type: CommonTypeNode | null = null;
if (tn.skip(Token.COLON)) {
type = this.parseType(tn);
if (!type) return null;
@ -1607,12 +1609,12 @@ export class Parser extends DiagnosticEmitter {
tn.range()
); // recoverable
}
var initializer: Expression | null = null;
let initializer: Expression | null = null;
if (tn.skip(Token.EQUALS)) {
initializer = this.parseExpression(tn);
if (!initializer) return null;
}
var retField = Node.createFieldDeclaration(
let retField = Node.createFieldDeclaration(
name,
type,
initializer,
@ -1642,15 +1644,15 @@ export class Parser extends DiagnosticEmitter {
var startPos = modifiers && modifiers.length ? modifiers[0].range.start : tn.tokenPos;
if (tn.skip(Token.IDENTIFIER)) {
var identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
let identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
if (tn.skip(Token.OPENBRACE)) {
var members = new Array<Statement>();
let members = new Array<Statement>();
while (!tn.skip(Token.CLOSEBRACE)) {
var member = this.parseTopLevelStatement(tn, true);
let member = this.parseTopLevelStatement(tn, true);
if (!member) return null;
members.push(member);
}
var ret = Node.createNamespaceDeclaration(
let ret = Node.createNamespaceDeclaration(
identifier,
members,
modifiers,
@ -1684,10 +1686,10 @@ export class Parser extends DiagnosticEmitter {
var startPos = modifiers && modifiers.length ? modifiers[0].range.start : tn.tokenPos;
if (tn.skip(Token.OPENBRACE)) {
var members = new Array<ExportMember>();
let members = new Array<ExportMember>();
if (!tn.skip(Token.CLOSEBRACE)) {
do {
var member = this.parseExportMember(tn);
let member = this.parseExportMember(tn);
if (!member) return null;
members.push(member);
} while (tn.skip(Token.COMMA));
@ -1699,7 +1701,7 @@ export class Parser extends DiagnosticEmitter {
return null;
}
}
var path: StringLiteralExpression | null = null;
let path: StringLiteralExpression | null = null;
if (tn.skip(Token.FROM)) {
if (tn.skip(Token.STRINGLITERAL)) {
path = Node.createStringLiteralExpression(tn.readString(), tn.range());
@ -1711,7 +1713,7 @@ export class Parser extends DiagnosticEmitter {
return null;
}
}
var ret = Node.createExportStatement(members, path, modifiers, tn.range(startPos, tn.pos));
let ret = Node.createExportStatement(members, path, modifiers, tn.range(startPos, tn.pos));
if (ret.normalizedPath && !this.seenlog.has(<string>ret.normalizedPath)) {
this.backlog.push(<string>ret.normalizedPath);
this.seenlog.add(<string>ret.normalizedPath);
@ -1734,8 +1736,8 @@ export class Parser extends DiagnosticEmitter {
// before: Identifier ('as' Identifier)?
if (tn.skip(Token.IDENTIFIER)) {
var identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
var asIdentifier: IdentifierExpression | null = null;
let identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
let asIdentifier: IdentifierExpression | null = null;
if (tn.skip(Token.AS)) {
if (tn.skip(Token.IDENTIFIER)) {
asIdentifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
@ -1779,7 +1781,7 @@ export class Parser extends DiagnosticEmitter {
members = new Array();
if (!tn.skip(Token.CLOSEBRACE)) {
do {
var member = this.parseImportDeclaration(tn);
let member = this.parseImportDeclaration(tn);
if (!member) return null;
members.push(member);
} while (tn.skip(Token.COMMA));
@ -1815,8 +1817,8 @@ export class Parser extends DiagnosticEmitter {
if (skipFrom || tn.skip(Token.FROM)) {
if (tn.skip(Token.STRINGLITERAL)) {
var path = Node.createStringLiteralExpression(tn.readString(), tn.range());
var ret: ImportStatement;
let path = Node.createStringLiteralExpression(tn.readString(), tn.range());
let ret: ImportStatement;
if (namespaceName) {
assert(!members);
ret = Node.createImportStatementWithWildcard(namespaceName, path, tn.range(startPos, tn.pos));
@ -1851,8 +1853,8 @@ export class Parser extends DiagnosticEmitter {
// before: Identifier ('as' Identifier)?
if (tn.skip(Token.IDENTIFIER)) {
var identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
var asIdentifier: IdentifierExpression | null = null;
let identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
let asIdentifier: IdentifierExpression | null = null;
if (tn.skip(Token.AS)) {
if (tn.skip(Token.IDENTIFIER)) {
asIdentifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
@ -1888,11 +1890,11 @@ export class Parser extends DiagnosticEmitter {
// at 'export' 'import': Identifier ('=' Identifier)? ';'?
if (tn.skip(Token.IDENTIFIER)) {
var asIdentifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
let asIdentifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
if (tn.skip(Token.EQUALS)) {
if (tn.skip(Token.IDENTIFIER)) {
var identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
var ret = Node.createExportImportStatement(identifier, asIdentifier, Range.join(startRange, tn.range()));
let identifier = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
let ret = Node.createExportImportStatement(identifier, asIdentifier, Range.join(startRange, tn.range()));
tn.skip(Token.SEMICOLON);
return ret;
} else {
@ -2004,7 +2006,7 @@ export class Parser extends DiagnosticEmitter {
var startPos = tn.tokenPos;
var statements = new Array<Statement>();
while (!tn.skip(Token.CLOSEBRACE)) {
var statement = this.parseStatement(tn, topLevel);
let statement = this.parseStatement(tn, topLevel);
if (!statement) return null;
statements.push(statement);
}
@ -2058,11 +2060,11 @@ export class Parser extends DiagnosticEmitter {
if (tn.skip(Token.WHILE)) {
if (tn.skip(Token.OPENPAREN)) {
var condition = this.parseExpression(tn);
let condition = this.parseExpression(tn);
if (!condition) return null;
if (tn.skip(Token.CLOSEPAREN)) {
var ret = Node.createDoStatement(<Statement>statement, <Expression>condition, tn.range(startPos, tn.pos));
let ret = Node.createDoStatement(<Statement>statement, <Expression>condition, tn.range(startPos, tn.pos));
tn.skip(Token.SEMICOLON);
return ret;
} else {
@ -2110,7 +2112,7 @@ export class Parser extends DiagnosticEmitter {
if (tn.skip(Token.OPENPAREN)) {
var initializer: Statement | null = null;
let initializer: Statement | null = null;
if (tn.skip(Token.LET) || tn.skip(Token.CONST) || tn.skip(Token.VAR)) {
initializer = this.parseVariable(tn, null, null);
@ -2121,14 +2123,14 @@ export class Parser extends DiagnosticEmitter {
}
if (tn.token == Token.SEMICOLON) {
var condition: ExpressionStatement | null = null;
let condition: ExpressionStatement | null = null;
if (!tn.skip(Token.SEMICOLON)) {
condition = this.parseExpressionStatement(tn);
if (!condition) return null;
}
if (tn.token == Token.SEMICOLON) {
var incrementor: Expression | null = null;
let incrementor: Expression | null = null;
if (!tn.skip(Token.CLOSEPAREN)) {
incrementor = this.parseExpression(tn);
if (!incrementor) return null;
@ -2142,7 +2144,7 @@ export class Parser extends DiagnosticEmitter {
}
}
var statement = this.parseStatement(tn);
let statement = this.parseStatement(tn);
if (!statement) return null;
return Node.createForStatement(
@ -2184,12 +2186,12 @@ export class Parser extends DiagnosticEmitter {
var startPos = tn.tokenPos;
if (tn.skip(Token.OPENPAREN)) {
var condition = this.parseExpression(tn);
let condition = this.parseExpression(tn);
if (!condition) return null;
if (tn.skip(Token.CLOSEPAREN)) {
var statement = this.parseStatement(tn);
let statement = this.parseStatement(tn);
if (!statement) return null;
var elseStatement: Statement | null = null;
let elseStatement: Statement | null = null;
if (tn.skip(Token.ELSE)) {
elseStatement = this.parseStatement(tn);
if (!elseStatement) return null;
@ -2223,17 +2225,17 @@ export class Parser extends DiagnosticEmitter {
var startPos = tn.tokenPos;
if (tn.skip(Token.OPENPAREN)) {
var condition = this.parseExpression(tn);
let condition = this.parseExpression(tn);
if (!condition) return null;
if (tn.skip(Token.CLOSEPAREN)) {
if (tn.skip(Token.OPENBRACE)) {
var cases = new Array<SwitchCase>();
let cases = new Array<SwitchCase>();
while (!tn.skip(Token.CLOSEBRACE)) {
var case_ = this.parseSwitchCase(tn);
let case_ = this.parseSwitchCase(tn);
if (!case_) return null;
cases.push(<SwitchCase>case_);
}
var ret = Node.createSwitchStatement(condition, cases, tn.range(startPos, tn.pos));
let ret = Node.createSwitchStatement(condition, cases, tn.range(startPos, tn.pos));
tn.skip(Token.SEMICOLON);
return ret;
} else {
@ -2268,7 +2270,7 @@ export class Parser extends DiagnosticEmitter {
// 'case' Expression ':' Statement*
if (tn.skip(Token.CASE)) {
var label = this.parseExpression(tn);
let label = this.parseExpression(tn);
if (!label) return null;
if (tn.skip(Token.COLON)) {
statements = new Array<Statement>();
@ -2337,15 +2339,15 @@ export class Parser extends DiagnosticEmitter {
var startPos = tn.tokenPos;
var stmt: Statement | null;
if (tn.skip(Token.OPENBRACE)) {
var statements = new Array<Statement>();
let statements = new Array<Statement>();
while (!tn.skip(Token.CLOSEBRACE)) {
stmt = this.parseStatement(tn);
if (!stmt) return null;
statements.push(<Statement>stmt);
}
var catchVariable: IdentifierExpression | null = null;
var catchStatements: Statement[] | null = null;
var finallyStatements: Statement[] | null = null;
let catchVariable: IdentifierExpression | null = null;
let catchStatements: Statement[] | null = null;
let finallyStatements: Statement[] | null = null;
if (tn.skip(Token.CATCH)) {
if (!tn.skip(Token.OPENPAREN)) {
this.error(
@ -2405,7 +2407,7 @@ export class Parser extends DiagnosticEmitter {
);
return null;
}
var ret = Node.createTryStatement(
let ret = Node.createTryStatement(
statements,
catchVariable,
catchStatements,
@ -2435,16 +2437,16 @@ export class Parser extends DiagnosticEmitter {
: modifiers && modifiers.length ? modifiers[0].range.start
: tn.tokenPos;
if (tn.skip(Token.IDENTIFIER)) {
var name = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
var typeParameters: TypeParameterNode[] | null = null;
let name = Node.createIdentifierExpression(tn.readIdentifier(), tn.range());
let typeParameters: TypeParameterNode[] | null = null;
if (tn.skip(Token.LESSTHAN)) {
typeParameters = this.parseTypeParameters(tn);
if (!typeParameters) return null;
}
if (tn.skip(Token.EQUALS)) {
var type = this.parseType(tn);
let type = this.parseType(tn);
if (!type) return null;
var ret = Node.createTypeDeclaration(
let ret = Node.createTypeDeclaration(
name,
typeParameters,
type,
@ -2491,12 +2493,12 @@ export class Parser extends DiagnosticEmitter {
var startPos = tn.tokenPos;
if (tn.skip(Token.OPENPAREN)) {
var expression = this.parseExpression(tn);
let expression = this.parseExpression(tn);
if (!expression) return null;
if (tn.skip(Token.CLOSEPAREN)) {
var statement = this.parseStatement(tn);
let statement = this.parseStatement(tn);
if (!statement) return null;
var ret = Node.createWhileStatement(expression, statement, tn.range(startPos, tn.pos));
let ret = Node.createWhileStatement(expression, statement, tn.range(startPos, tn.pos));
tn.skip(Token.SEMICOLON);
return ret;
} else {
@ -2537,7 +2539,7 @@ export class Parser extends DiagnosticEmitter {
var p = determinePrecedenceStart(token);
if (p != Precedence.INVALID) {
var operand: Expression | null;
let operand: Expression | null;
// TODO: SpreadExpression, YieldExpression (currently become unsupported UnaryPrefixExpressions)
@ -2595,8 +2597,8 @@ export class Parser extends DiagnosticEmitter {
true
);
}
var state = tn.mark();
var again = true;
let state = tn.mark();
let again = true;
do {
switch (tn.next(true)) {
@ -2660,7 +2662,7 @@ export class Parser extends DiagnosticEmitter {
}
// ArrayLiteralExpression
case Token.OPENBRACKET: {
var elementExpressions = new Array<Expression | null>();
let elementExpressions = new Array<Expression | null>();
if (!tn.skip(Token.CLOSEBRACKET)) {
do {
if (tn.peek() == Token.COMMA) {
@ -2684,7 +2686,7 @@ export class Parser extends DiagnosticEmitter {
}
// AssertionExpression (unary prefix)
case Token.LESSTHAN: {
var toType = this.parseType(tn);
let toType = this.parseType(tn);
if (!toType) return null;
if (!tn.skip(Token.GREATERTHAN)) {
this.error(
@ -2726,7 +2728,7 @@ export class Parser extends DiagnosticEmitter {
// RegexpLiteralExpression
// note that this also continues on invalid ones so the surrounding AST remains intact
case Token.SLASH: {
var regexpPattern = tn.readRegexpPattern(); // also reports
let regexpPattern = tn.readRegexpPattern(); // also reports
if (!tn.skip(Token.SLASH)) {
this.error(
DiagnosticCode._0_expected,
@ -2763,7 +2765,7 @@ export class Parser extends DiagnosticEmitter {
if (!tn.skip(Token.LESSTHAN)) return null;
var typeArguments = new Array<CommonTypeNode>();
do {
var type = this.parseType(tn, true, true);
let type = this.parseType(tn, true, true);
if (!type) {
tn.reset(state);
return null;
@ -2786,7 +2788,7 @@ export class Parser extends DiagnosticEmitter {
var args = new Array<Expression>();
if (!tn.skip(Token.CLOSEPAREN)) {
do {
var expr = this.parseExpression(tn, Precedence.COMMA + 1);
let expr = this.parseExpression(tn, Precedence.COMMA + 1);
if (!expr) return null;
args.push(expr);
} while (tn.skip(Token.COMMA));
@ -2832,7 +2834,7 @@ export class Parser extends DiagnosticEmitter {
switch (token) {
// AssertionExpression
case Token.AS: {
var toType = this.parseType(tn);
let toType = this.parseType(tn);
if (!toType) return null;
expr = Node.createAssertionExpression(
AssertionKind.AS,
@ -2882,7 +2884,7 @@ export class Parser extends DiagnosticEmitter {
}
// TernaryExpression
case Token.QUESTION: {
var ifThen = this.parseExpression(tn);
let ifThen = this.parseExpression(tn);
if (!ifThen) return null;
if (!tn.skip(Token.COLON)) {
this.error(
@ -2891,7 +2893,7 @@ export class Parser extends DiagnosticEmitter {
);
return null;
}
var ifElse = this.parseExpression(tn);
let ifElse = this.parseExpression(tn);
if (!ifElse) return null;
expr = Node.createTernaryExpression(
expr,
@ -2903,7 +2905,7 @@ export class Parser extends DiagnosticEmitter {
}
// CommaExpression
case Token.COMMA: {
var commaExprs: Expression[] = [ expr ];
let commaExprs: Expression[] = [ expr ];
do {
expr = this.parseExpression(tn, Precedence.COMMA + 1);
if (!expr) return null;
@ -2929,7 +2931,7 @@ export class Parser extends DiagnosticEmitter {
tn.range(startPos, tn.pos)
);
} else if (next.kind == NodeKind.CALL) { // join
var propertyCall = <CallExpression>next;
let propertyCall = <CallExpression>next;
if (propertyCall.expression.kind == NodeKind.IDENTIFIER) {
propertyCall.expression = Node.createPropertyAccessExpression(
expr,

162
src/program.ts
View File

@ -304,7 +304,7 @@ export class Program extends DiagnosticEmitter {
var element: Element | null;
do {
if (element = this.exports.get(referencedName)) return element;
var queuedExport = queuedExports.get(referencedName);
let queuedExport = queuedExports.get(referencedName);
if (!queuedExport) return null;
if (queuedExport.isReExport) {
referencedName = queuedExport.referencedName;
@ -501,7 +501,7 @@ export class Program extends DiagnosticEmitter {
} else {
classPrototype.members = new Map();
}
var staticField = new Global(
let staticField = new Global(
this, name, internalName, declaration, Type.void
);
classPrototype.members.set(name, staticField);
@ -520,7 +520,7 @@ export class Program extends DiagnosticEmitter {
} else {
classPrototype.instanceMembers = new Map();
}
var instanceField = new FieldPrototype(
let instanceField = new FieldPrototype(
classPrototype,
name, internalName,
declaration
@ -618,8 +618,8 @@ export class Program extends DiagnosticEmitter {
// arguments of the instance's type. return values vary depending on the
// operation.
if (decorators) {
for (var i = 0, k = decorators.length; i < k; ++i) {
var decorator = decorators[i];
for (let i = 0, k = decorators.length; i < k; ++i) {
let decorator = decorators[i];
if (decorator.decoratorKind == DecoratorKind.OPERATOR) {
if (!prototype) {
this.error(
@ -628,9 +628,9 @@ export class Program extends DiagnosticEmitter {
);
continue;
}
var numArgs = decorator.arguments && decorator.arguments.length || 0;
let numArgs = decorator.arguments && decorator.arguments.length || 0;
if (numArgs == 1) {
var firstArg = (<Expression[]>decorator.arguments)[0];
let firstArg = (<Expression[]>decorator.arguments)[0];
if (
firstArg.kind == NodeKind.LITERAL &&
(<LiteralExpression>firstArg).literalKind == LiteralKind.STRING
@ -717,7 +717,7 @@ export class Program extends DiagnosticEmitter {
// static accessors become global functions
if (hasModifier(ModifierKind.STATIC, declaration.modifiers)) {
var staticName = classPrototype.internalName + STATIC_DELIMITER + name;
let staticName = classPrototype.internalName + STATIC_DELIMITER + name;
if (this.elements.has(staticName)) {
this.error(
DiagnosticCode.Duplicate_identifier_0,
@ -725,7 +725,7 @@ export class Program extends DiagnosticEmitter {
);
return;
}
var staticPrototype = new FunctionPrototype(
let staticPrototype = new FunctionPrototype(
this,
name, staticName,
declaration,
@ -744,7 +744,7 @@ export class Program extends DiagnosticEmitter {
// instance accessors are remembered until resolved
} else {
var instanceName = classPrototype.internalName + INSTANCE_DELIMITER + name;
let instanceName = classPrototype.internalName + INSTANCE_DELIMITER + name;
if (classPrototype.instanceMembers) {
if (classPrototype.instanceMembers.has(name)) {
this.error(
@ -756,7 +756,7 @@ export class Program extends DiagnosticEmitter {
} else {
classPrototype.instanceMembers = new Map();
}
var instancePrototype = new FunctionPrototype(
let instancePrototype = new FunctionPrototype(
this,
name, instanceName,
declaration,
@ -815,7 +815,7 @@ export class Program extends DiagnosticEmitter {
}
var values = declaration.values;
for (var i = 0, k = values.length; i < k; ++i) {
for (let i = 0, k = values.length; i < k; ++i) {
this.initializeEnumValue(values[i], enm);
}
}
@ -846,7 +846,7 @@ export class Program extends DiagnosticEmitter {
queuedExports: Map<string,QueuedExport>
): void {
var members = statement.members;
for (var i = 0, k = members.length; i < k; ++i) {
for (let i = 0, k = members.length; i < k; ++i) {
this.initializeExport(members[i], statement.internalPath, queuedExports);
}
}
@ -931,7 +931,7 @@ export class Program extends DiagnosticEmitter {
}
// walk already known queued exports
var seen = new Set<QueuedExport>();
let seen = new Set<QueuedExport>();
while (queuedExport = queuedExports.get(referencedName)) {
if (queuedExport.isReExport) {
referencedElement = this.exports.get(queuedExport.referencedName);
@ -1031,7 +1031,7 @@ export class Program extends DiagnosticEmitter {
): void {
var declarations = statement.declarations;
if (declarations) {
for (var i = 0, k = declarations.length; i < k; ++i) {
for (let i = 0, k = declarations.length; i < k; ++i) {
this.initializeImport(
declarations[i],
statement.internalPath,
@ -1039,7 +1039,7 @@ export class Program extends DiagnosticEmitter {
);
}
} else if (statement.namespaceName) {
var internalName = (
let internalName = (
statement.range.source.internalPath +
PATH_DELIMITER +
statement.namespaceName.text
@ -1146,8 +1146,8 @@ export class Program extends DiagnosticEmitter {
}
var memberDeclarations = declaration.members;
for (var i = 0, k = memberDeclarations.length; i < k; ++i) {
var memberDeclaration = memberDeclarations[i];
for (let i = 0, k = memberDeclarations.length; i < k; ++i) {
let memberDeclaration = memberDeclarations[i];
switch (memberDeclaration.kind) {
case NodeKind.FIELDDECLARATION: {
@ -1155,7 +1155,7 @@ export class Program extends DiagnosticEmitter {
break;
}
case NodeKind.METHODDECLARATION: {
var isGetter = hasModifier(ModifierKind.GET, memberDeclaration.modifiers);
let isGetter = hasModifier(ModifierKind.GET, memberDeclaration.modifiers);
if (isGetter || hasModifier(ModifierKind.SET, memberDeclaration.modifiers)) {
this.initializeAccessor(<MethodDeclaration>memberDeclaration, prototype, isGetter);
} else {
@ -1210,7 +1210,7 @@ export class Program extends DiagnosticEmitter {
}
var members = declaration.members;
for (var i = 0, k = members.length; i < k; ++i) {
for (let i = 0, k = members.length; i < k; ++i) {
switch (members[i].kind) {
case NodeKind.CLASSDECLARATION: {
this.initializeClass(<ClassDeclaration>members[i], queuedExtendingClasses, namespace);
@ -1271,9 +1271,9 @@ export class Program extends DiagnosticEmitter {
private initializeVariables(statement: VariableStatement, namespace: Element | null = null): void {
var declarations = statement.declarations;
for (var i = 0, k = declarations.length; i < k; ++i) {
var declaration = declarations[i];
var internalName = declaration.fileLevelInternalName;
for (let i = 0, k = declarations.length; i < k; ++i) {
let declaration = declarations[i];
let internalName = declaration.fileLevelInternalName;
if (this.elements.has(internalName)) {
this.error(
DiagnosticCode.Duplicate_identifier_0,
@ -1282,7 +1282,7 @@ export class Program extends DiagnosticEmitter {
continue;
}
var global = new Global(
let global = new Global(
this,
declaration.name.text,
internalName,
@ -1405,7 +1405,7 @@ export class Program extends DiagnosticEmitter {
if ((element = this.elements.get(localName)) || (element = this.elements.get(globalName))) {
switch (element.kind) {
case ElementKind.CLASS_PROTOTYPE: {
var instance = (<ClassPrototype>element).resolveUsingTypeArguments(
let instance = (<ClassPrototype>element).resolveUsingTypeArguments(
typeNode.typeArguments,
contextualTypeArguments,
null
@ -1421,10 +1421,10 @@ export class Program extends DiagnosticEmitter {
// resolve parameters
if (typeNode.typeArguments) {
var k = typeNode.typeArguments.length;
var paramTypes = new Array<Type>(k);
for (var i = 0; i < k; ++i) {
var paramType = this.resolveType( // reports
let k = typeNode.typeArguments.length;
let paramTypes = new Array<Type>(k);
for (let i = 0; i < k; ++i) {
let paramType = this.resolveType( // reports
typeNode.typeArguments[i],
contextualTypeArguments,
reportNotFound
@ -1434,13 +1434,13 @@ export class Program extends DiagnosticEmitter {
}
if (k) { // can't be a placeholder if it has parameters
var instanceKey = typesToString(paramTypes);
let instanceKey = typesToString(paramTypes);
if (instanceKey.length) {
localName += "<" + instanceKey + ">";
globalName += "<" + instanceKey + ">";
}
} else if (contextualTypeArguments) {
var placeholderType = contextualTypeArguments.get(globalName);
let placeholderType = contextualTypeArguments.get(globalName);
if (placeholderType) return placeholderType;
}
}
@ -1489,8 +1489,8 @@ export class Program extends DiagnosticEmitter {
return null;
}
var typeArguments = new Array<Type>(parameterCount);
for (var i = 0; i < parameterCount; ++i) {
var type = this.resolveType( // reports
for (let i = 0; i < parameterCount; ++i) {
let type = this.resolveType( // reports
(<TypeNode[]>typeArgumentNodes)[i],
contextualTypeArguments,
true
@ -1598,7 +1598,7 @@ export class Program extends DiagnosticEmitter {
break;
}
case ElementKind.PROPERTY: {
var getter = assert((<Property>target).getterPrototype).resolve(); // reports
let getter = assert((<Property>target).getterPrototype).resolve(); // reports
if (!getter) return null;
if (!(targetType = getter.signature.returnType).classType) {
this.error(
@ -1670,10 +1670,10 @@ export class Program extends DiagnosticEmitter {
case ElementKind.GLOBAL:
case ElementKind.LOCAL:
case ElementKind.FIELD: {
var type = (<VariableLikeElement>target).type;
let type = (<VariableLikeElement>target).type;
if (type.classType) {
var indexedGetName = (target = type.classType).prototype.fnIndexedGet;
var indexedGet: Element | null;
let indexedGetName = (target = type.classType).prototype.fnIndexedGet;
let indexedGet: Element | null;
if (
indexedGetName != null &&
target.members &&
@ -1969,9 +1969,10 @@ export class Namespace extends Element {
) {
super(program, simpleName, internalName);
this.declaration = declaration;
if (this.declaration.modifiers) {
for (var i = 0, k = this.declaration.modifiers.length; i < k; ++i) {
switch (this.declaration.modifiers[i].modifierKind) {
var modifiers = declaration.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
switch (modifiers[i].modifierKind) {
case ModifierKind.IMPORT: {
this.set(ElementFlags.IMPORTED);
break;
@ -2008,9 +2009,10 @@ export class Enum extends Element {
) {
super(program, simpleName, internalName);
this.declaration = declaration;
if (this.declaration.modifiers) {
for (var i = 0, k = this.declaration.modifiers.length; i < k; ++i) {
switch (this.declaration.modifiers[i].modifierKind) {
var modifiers = declaration.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
switch (modifiers[i].modifierKind) {
case ModifierKind.EXPORT: {
this.set(ElementFlags.EXPORTED);
break;
@ -2109,9 +2111,10 @@ export class Global extends VariableLikeElement {
) {
super(program, simpleName, internalName);
this.declaration = declaration;
if (this.declaration.modifiers) {
for (var i = 0, k = this.declaration.modifiers.length; i < k; ++i) {
switch (this.declaration.modifiers[i].modifierKind) {
var modifiers = declaration.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
switch (modifiers[i].modifierKind) {
case ModifierKind.IMPORT: {
this.set(ElementFlags.IMPORTED);
break;
@ -2210,9 +2213,10 @@ export class FunctionPrototype extends Element {
) {
super(program, simpleName, internalName);
this.declaration = declaration;
if (this.declaration.modifiers) {
for (var i = 0, k = this.declaration.modifiers.length; i < k; ++i) {
switch (this.declaration.modifiers[i].modifierKind) {
var modifiers = declaration.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
switch (modifiers[i].modifierKind) {
case ModifierKind.IMPORT: {
this.set(ElementFlags.IMPORTED);
break;
@ -2365,7 +2369,7 @@ export class FunctionPrototype extends Element {
throw new Error("partially resolved instance method must reference its class prototype");
}
if (classTypeArguments && classTypeArguments.length) {
var partialPrototype = new FunctionPrototype(
let partialPrototype = new FunctionPrototype(
this.program,
this.simpleName,
this.internalName,
@ -2407,10 +2411,10 @@ export class FunctionPrototype extends Element {
assert(this.is(ElementFlags.BUILTIN));
var resolvedTypeArguments: Type[] | null = null;
if (typeArgumentNodes) {
var k = typeArgumentNodes.length;
let k = typeArgumentNodes.length;
resolvedTypeArguments = new Array<Type>(k);
for (var i = 0; i < k; ++i) {
var resolvedType = this.program.resolveType( // reports
for (let i = 0; i < k; ++i) {
let resolvedType = this.program.resolveType( // reports
typeArgumentNodes[i],
contextualTypeArguments,
true
@ -2561,7 +2565,7 @@ export class Function extends Element {
default: throw new Error("concrete type expected");
}
if (temps && temps.length) {
var ret = temps.pop();
let ret = temps.pop();
ret.type = type;
return ret;
}
@ -2657,10 +2661,10 @@ export class Function extends Element {
this.breakContext = null;
this.tempI32s = this.tempI64s = this.tempF32s = this.tempF64s = null;
if (this.program.options.sourceMap) {
var debugLocations = this.debugLocations;
let debugLocations = this.debugLocations;
if (debugLocations) {
for (var i = 0, k = debugLocations.length; i < k; ++i) {
var debugLocation = debugLocations[i];
for (let i = 0, k = debugLocations.length; i < k; ++i) {
let debugLocation = debugLocations[i];
module.setDebugLocation(
ref,
debugLocation.debugInfoRef,
@ -2678,7 +2682,7 @@ export class Function extends Element {
toString(): string { return this.prototype.simpleName; }
}
/** A resolved function table entry, that is an function called by an index and signature. */
/** A resolved function target, that is a function called indirectly by an index and signature. */
export class FunctionTarget extends Element {
kind = ElementKind.FUNCTION_TARGET;
@ -2719,9 +2723,10 @@ export class FieldPrototype extends Element {
super(classPrototype.program, simpleName, internalName);
this.classPrototype = classPrototype;
this.declaration = declaration;
if (this.declaration.modifiers) {
for (var i = 0, k = this.declaration.modifiers.length; i < k; ++i) {
switch (this.declaration.modifiers[i].modifierKind) {
var modifiers = declaration.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
switch (modifiers[i].modifierKind) {
case ModifierKind.EXPORT: {
this.set(ElementFlags.EXPORTED);
break;
@ -2829,9 +2834,10 @@ export class ClassPrototype extends Element {
) {
super(program, simpleName, internalName);
this.declaration = declaration;
if (this.declaration.modifiers) {
for (var i = 0, k = this.declaration.modifiers.length; i < k; ++i) {
switch (this.declaration.modifiers[i].modifierKind) {
var modifiers = declaration.modifiers;
if (modifiers) {
for (let i = 0, k = modifiers.length; i < k; ++i) {
switch (modifiers[i].modifierKind) {
case ModifierKind.IMPORT: {
this.set(ElementFlags.IMPORTED);
break;
@ -2848,7 +2854,7 @@ export class ClassPrototype extends Element {
}
}
}
if (this.declaration.typeParameters.length) {
if (declaration.typeParameters.length) {
this.set(ElementFlags.GENERIC);
}
}
@ -2878,7 +2884,7 @@ export class ClassPrototype extends Element {
var inheritedTypeArguments = contextualTypeArguments;
contextualTypeArguments = new Map();
if (inheritedTypeArguments) {
for (var [inheritedName, inheritedType] of inheritedTypeArguments) {
for (let [inheritedName, inheritedType] of inheritedTypeArguments) {
contextualTypeArguments.set(inheritedName, inheritedType);
}
}
@ -2886,7 +2892,7 @@ export class ClassPrototype extends Element {
var declaration = this.declaration;
var baseClass: Class | null = null;
if (declaration.extendsType) {
var baseClassType = this.program.resolveType(declaration.extendsType, null); // reports
let baseClassType = this.program.resolveType(declaration.extendsType, null); // reports
if (!baseClassType) return null;
if (!(baseClass = baseClassType.classType)) {
this.program.error(
@ -2930,14 +2936,14 @@ export class ClassPrototype extends Element {
memoryOffset = baseClass.currentMemoryOffset;
if (baseClass.members) {
if (!instance.members) instance.members = new Map();
for (var inheritedMember of baseClass.members.values()) {
for (let inheritedMember of baseClass.members.values()) {
instance.members.set(inheritedMember.simpleName, inheritedMember);
}
}
}
if (this.constructorPrototype) {
var partialConstructor = this.constructorPrototype.resolvePartial(typeArguments); // reports
let partialConstructor = this.constructorPrototype.resolvePartial(typeArguments); // reports
if (partialConstructor) {
instance.constructorInstance = partialConstructor.resolve(); // reports
}
@ -2945,20 +2951,20 @@ export class ClassPrototype extends Element {
}
if (this.instanceMembers) {
for (var member of this.instanceMembers.values()) {
for (let member of this.instanceMembers.values()) {
switch (member.kind) {
case ElementKind.FIELD_PROTOTYPE: { // fields are layed out in advance
if (!instance.members) instance.members = new Map();
var fieldDeclaration = (<FieldPrototype>member).declaration;
let fieldDeclaration = (<FieldPrototype>member).declaration;
if (!fieldDeclaration.type) {
throw new Error("type expected"); // TODO: check if parent class defines a type
}
var fieldType = this.program.resolveType( // reports
let fieldType = this.program.resolveType( // reports
fieldDeclaration.type,
instance.contextualTypeArguments
);
if (fieldType) {
var fieldInstance = new Field(<FieldPrototype>member, (<FieldPrototype>member).internalName, fieldType);
let fieldInstance = new Field(<FieldPrototype>member, (<FieldPrototype>member).internalName, fieldType);
switch (fieldType.byteSize) { // align
case 1: break;
case 2: {
@ -2983,7 +2989,7 @@ export class ClassPrototype extends Element {
}
case ElementKind.FUNCTION_PROTOTYPE: { // instance methods remain partially resolved prototypes until compiled
if (!instance.members) instance.members = new Map();
var methodPrototype = (<FunctionPrototype>member).resolvePartial(typeArguments); // reports
let methodPrototype = (<FunctionPrototype>member).resolvePartial(typeArguments); // reports
if (methodPrototype) {
instance.members.set(member.simpleName, methodPrototype);
}
@ -2992,7 +2998,7 @@ export class ClassPrototype extends Element {
case ElementKind.PROPERTY: { // instance properties are cloned with partially resolved getters and setters
if (!instance.members) instance.members = new Map();
assert((<Property>member).getterPrototype);
var instanceProperty = new Property(this.program, member.simpleName, member.internalName, this);
let instanceProperty = new Property(this.program, member.simpleName, member.internalName, this);
instanceProperty.getterPrototype = (
(<FunctionPrototype>(<Property>member).getterPrototype).resolvePartial(
typeArguments
@ -3081,7 +3087,7 @@ export class Class extends Element {
if (base) {
if (base.contextualTypeArguments) {
if (!this.contextualTypeArguments) this.contextualTypeArguments = new Map();
for (var [baseName, baseType] of base.contextualTypeArguments) {
for (let [baseName, baseType] of base.contextualTypeArguments) {
this.contextualTypeArguments.set(baseName, baseType);
}
}
@ -3091,7 +3097,7 @@ export class Class extends Element {
var declaration = this.prototype.declaration;
var i: i32, k: i32;
if (declaration) { // irrelevant for built-ins
var typeParameters = declaration.typeParameters;
let typeParameters = declaration.typeParameters;
if (typeArguments) {
if ((k = typeArguments.length) != typeParameters.length) {
throw new Error("type argument count mismatch");
@ -3230,7 +3236,7 @@ export class Flow {
// Free block-scoped locals
if (this.scopedLocals) {
for (var scopedLocal of this.scopedLocals.values()) {
for (let scopedLocal of this.scopedLocals.values()) {
this.currentFunction.freeTempLocal(scopedLocal);
}
this.scopedLocals = null;

40
src/tokenizer.ts
View File

@ -441,7 +441,7 @@ export class Tokenizer extends DiagnosticEmitter {
var text = this.source.text;
while (this.pos < this.end) {
this.tokenPos = this.pos;
var c = text.charCodeAt(this.pos);
let c = text.charCodeAt(this.pos);
switch (c) {
case CharCode.CARRIAGERETURN: {
if (
@ -603,7 +603,7 @@ export class Tokenizer extends DiagnosticEmitter {
continue;
}
if (text.charCodeAt(this.pos) == CharCode.ASTERISK) { // multi-line
var closed = false;
let closed = false;
while (++this.pos < this.end) {
c = text.charCodeAt(this.pos);
if (
@ -784,7 +784,7 @@ export class Tokenizer extends DiagnosticEmitter {
default: {
if (isIdentifierStart(c)) {
if (isKeywordCharacter(c)) {
var posBefore = this.pos;
let posBefore = this.pos;
while (
++this.pos < this.end &&
isIdentifierPart(c = text.charCodeAt(this.pos))
@ -794,8 +794,8 @@ export class Tokenizer extends DiagnosticEmitter {
return Token.IDENTIFIER;
}
}
var keywordText = text.substring(posBefore, this.pos);
var keywordToken = Token.fromKeyword(keywordText);
let keywordText = text.substring(posBefore, this.pos);
let keywordToken = Token.fromKeyword(keywordText);
if (
keywordToken != Token.INVALID &&
!(preferIdentifier && Token.isAlsoIdentifier(keywordToken))
@ -828,9 +828,9 @@ export class Tokenizer extends DiagnosticEmitter {
): Token {
var text = this.source.text;
if (this.nextToken < 0) {
var posBefore = this.pos;
var tokenBefore = this.token;
var tokenPosBefore = this.tokenPos;
let posBefore = this.pos;
let tokenBefore = this.token;
let tokenPosBefore = this.tokenPos;
this.nextToken = this.unsafeNext(preferIdentifier, maxCompoundLength);
if (checkOnNewLine) {
this.nextTokenOnNewLine = false;
@ -942,7 +942,7 @@ export class Tokenizer extends DiagnosticEmitter {
);
break;
}
var c = text.charCodeAt(this.pos);
let c = text.charCodeAt(this.pos);
if (c == quote) {
result += text.substring(start, this.pos++);
break;
@ -1030,7 +1030,7 @@ export class Tokenizer extends DiagnosticEmitter {
escaped = true;
continue;
}
var c = text.charCodeAt(this.pos);
let c = text.charCodeAt(this.pos);
if (c == CharCode.SLASH && !escaped) break;
if (isLineBreak(c)) {
this.error(
@ -1050,7 +1050,7 @@ export class Tokenizer extends DiagnosticEmitter {
var start = this.pos;
var flags = 0;
while (this.pos < this.end) {
var c: i32 = text.charCodeAt(this.pos);
let c: i32 = text.charCodeAt(this.pos);
if (!isIdentifierPart(c)) break;
++this.pos;
@ -1097,7 +1097,7 @@ export class Tokenizer extends DiagnosticEmitter {
}
var pos = this.pos;
while (pos < this.end) {
var c = text.charCodeAt(pos);
let c = text.charCodeAt(pos);
if (c == CharCode.DOT || c == CharCode.E || c == CharCode.e) {
return false;
}
@ -1128,9 +1128,9 @@ export class Tokenizer extends DiagnosticEmitter {
}
}
if (isOctalDigit(text.charCodeAt(this.pos + 1))) {
var start = this.pos;
let start = this.pos;
++this.pos;
var value = this.readOctalInteger();
let value = this.readOctalInteger();
this.error(
DiagnosticCode.Octal_literals_are_not_allowed_in_strict_mode,
this.range(start, this.pos)
@ -1147,7 +1147,7 @@ export class Tokenizer extends DiagnosticEmitter {
var value = i64_new(0, 0);
var i64_16 = i64_new(16, 0);
while (this.pos < this.end) {
var c = text.charCodeAt(this.pos);
let c = text.charCodeAt(this.pos);
if (c >= CharCode._0 && c <= CharCode._9) {
// value = value * 16 + c - CharCode._0;
value = i64_add(
@ -1186,7 +1186,7 @@ export class Tokenizer extends DiagnosticEmitter {
var value = i64_new(0, 0);
var i64_10 = i64_new(10, 0);
while (this.pos < this.end) {
var c = text.charCodeAt(this.pos);
let c = text.charCodeAt(this.pos);
if (c >= CharCode._0 && c <= CharCode._9) {
// value = value * 10 + c - CharCode._0;
value = i64_add(
@ -1213,7 +1213,7 @@ export class Tokenizer extends DiagnosticEmitter {
var value = i64_new(0, 0);
var i64_8 = i64_new(8, 0);
while (this.pos < this.end) {
var c = text.charCodeAt(this.pos);
let c = text.charCodeAt(this.pos);
if (c >= CharCode._0 && c <= CharCode._7) {
// value = value * 8 + c - CharCode._0;
value = i64_add(
@ -1241,7 +1241,7 @@ export class Tokenizer extends DiagnosticEmitter {
var i64_2 = i64_new(2, 0);
var i64_1 = i64_new(1, 0);
while (this.pos < this.end) {
var c = text.charCodeAt(this.pos);
let c = text.charCodeAt(this.pos);
if (c == CharCode._0) {
// value = value * 2;
value = i64_mul(
@ -1281,7 +1281,7 @@ export class Tokenizer extends DiagnosticEmitter {
}
}
if (this.pos < this.end) {
var c = text.charCodeAt(this.pos);
let c = text.charCodeAt(this.pos);
if (c == CharCode.E || c == CharCode.e) {
if (
++this.pos < this.end && (
@ -1305,7 +1305,7 @@ export class Tokenizer extends DiagnosticEmitter {
var value = 0;
var text = this.source.text;
while (this.pos < this.end) {
var c = text.charCodeAt(this.pos++);
let c = text.charCodeAt(this.pos++);
if (c >= CharCode._0 && c <= CharCode._9) {
value = value * 16 + c - CharCode._0;
} else if (c >= CharCode.A && c <= CharCode.F) {

16
src/types.ts
View File

@ -419,9 +419,9 @@ export class Type {
/** Converts an array of types to an array of native types. */
export function typesToNativeTypes(types: Type[]): NativeType[] {
var k = types.length;
var ret = new Array<NativeType>(k);
for (var i = 0; i < k; ++i) {
var numTypes = types.length;
var ret = new Array<NativeType>(numTypes);
for (let i = 0; i < numTypes; ++i) {
ret[i] = types[i].toNativeType();
}
return ret;
@ -429,10 +429,10 @@ export function typesToNativeTypes(types: Type[]): NativeType[] {
/** Converts an array of types to its combined string representation. */
export function typesToString(types: Type[]): string {
var k = types.length;
if (!k) return "";
var sb = new Array<string>(k);
for (var i = 0; i < k; ++i) {
var numTypes = types.length;
if (!numTypes) return "";
var sb = new Array<string>(numTypes);
for (let i = 0; i < numTypes; ++i) {
sb[i] = types[i].toString();
}
return sb.join(", ");
@ -580,7 +580,7 @@ var cachedGenericParameterNames: string[] | null = null;
/** Gets the cached generic parameter name for the specified index. */
export function getGenericParameterName(index: i32): string {
if (!cachedGenericParameterNames) cachedGenericParameterNames = [];
for (var i = cachedGenericParameterNames.length; i < index; ++i) {
for (let i = cachedGenericParameterNames.length; i < index; ++i) {
cachedGenericParameterNames.push("arg$" + i.toString(10));
}
return cachedGenericParameterNames[index];

2
src/util/path.ts
View File

@ -56,7 +56,7 @@ export function normalize(path: string): string {
path.charCodeAt(pos + 3) == separator
) {
// find preceeding '/'
var ipos = pos;
let ipos = pos;
while (--ipos >= 0) {
if (path.charCodeAt(ipos) == separator) {
if (pos - ipos != 3 ||

4
std/assembly/allocator/arena.ts
View File

@ -16,8 +16,8 @@ export function allocate_memory(size: usize): usize {
var newPtr = (ptr + size + AL_MASK) & ~AL_MASK;
var pagesBefore = current_memory();
if (newPtr > <usize>pagesBefore << 16) {
var pagesNeeded = ((newPtr - ptr + 0xffff) & ~0xffff) >>> 16;
var pagesWanted = max(pagesBefore, pagesNeeded); // double memory
let pagesNeeded = ((newPtr - ptr + 0xffff) & ~0xffff) >>> 16;
let pagesWanted = max(pagesBefore, pagesNeeded); // double memory
if (grow_memory(pagesWanted) < 0) {
if (grow_memory(pagesNeeded) < 0) {
unreachable(); // out of memory

12
std/assembly/allocator/buddy.ts
View File

@ -175,8 +175,8 @@ function update_max_ptr(new_value: usize): i32 {
// if (brk(new_value)) {
// return 0;
// }
var oldPages = <u32>current_memory();
var newPages = <u32>(((new_value + 0xffff) & ~0xffff) >> 16);
let oldPages = <u32>current_memory();
let newPages = <u32>(((new_value + 0xffff) & ~0xffff) >> 16);
assert(newPages > oldPages);
if (grow_memory(newPages - oldPages) < 0) {
return 0;
@ -293,8 +293,8 @@ function bucket_for_request(request: usize): usize {
*/
function lower_bucket_limit(bucket: usize): u32 {
while (bucket < bucket_limit) {
var root = node_for_ptr(base_ptr, bucket_limit);
var right_child: usize;
let root = node_for_ptr(base_ptr, bucket_limit);
let right_child: usize;
/*
* If the parent isn't SPLIT, that means the node at the current bucket
@ -380,8 +380,8 @@ export function allocate_memory(request: usize): usize {
* larger one to get a match.
*/
while (bucket + 1 != 0) {
var size: usize, bytes_needed: usize, i: usize;
var ptr: usize;
let size: usize, bytes_needed: usize, i: usize;
let ptr: usize;
/*
* We may need to grow the tree to be able to fit an allocation of this

34
std/assembly/allocator/tlsf.ts
View File

@ -206,8 +206,8 @@ class Root {
// merge with left block if also free
if (blockInfo & LEFT_FREE) {
var left: Block = assert(block.left); // can't be null
var leftInfo = left.info;
let left: Block = assert(block.left); // can't be null
let leftInfo = left.info;
assert(leftInfo & FREE); // must be free according to tags
this.remove(left);
left.info = (leftInfo += Block.INFO + (blockInfo & ~TAGS));
@ -280,7 +280,7 @@ class Root {
// clear second level map if head is empty now
if (!next) {
var slMap = this.getSLMap(fl);
let slMap = this.getSLMap(fl);
this.setSLMap(fl, slMap &= ~(1 << sl));
// clear first level map if second level is empty now
@ -313,7 +313,7 @@ class Root {
var head: Block | null;
if (!slMap) {
// search next larger first level
var flMap = this.flMap & (~0 << (fl + 1));
let flMap = this.flMap & (~0 << (fl + 1));
if (!flMap) {
head = null;
} else {
@ -354,7 +354,7 @@ class Root {
if (remaining >= Block.INFO + Block.MIN_SIZE) {
block.info = size | (blockInfo & LEFT_FREE); // also discards FREE
var spare = changetype<Block>(
let spare = changetype<Block>(
changetype<usize>(block) + Block.INFO + size
);
spare.info = (remaining - Block.INFO) | FREE; // not LEFT_FREE
@ -363,7 +363,7 @@ class Root {
// otherwise tag block as no longer FREE and right as no longer LEFT_FREE
} else {
block.info = blockInfo & ~FREE;
var right: Block = assert(block.right); // can't be null (tail)
let right: Block = assert(block.right); // can't be null (tail)
right.info &= ~LEFT_FREE;
}
@ -440,13 +440,13 @@ export function allocate_memory(size: usize): usize {
// initialize if necessary
var root = ROOT;
if (!root) {
var rootOffset = (HEAP_BASE + AL_MASK) & ~AL_MASK;
let rootOffset = (HEAP_BASE + AL_MASK) & ~AL_MASK;
ROOT = root = changetype<Root>(rootOffset);
root.tailRef = 0;
root.flMap = 0;
for (var fl: usize = 0; fl < FL_BITS; ++fl) {
for (let fl: usize = 0; fl < FL_BITS; ++fl) {
root.setSLMap(fl, 0);
for (var sl: u32 = 0; sl < SL_SIZE; ++sl) {
for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {
root.setHead(fl, sl, null);
}
}
@ -458,19 +458,19 @@ export function allocate_memory(size: usize): usize {
if (size && size < Block.MAX_SIZE) {
size = max<usize>((size + AL_MASK) & ~AL_MASK, Block.MIN_SIZE);
var block = root.search(size);
let block = root.search(size);
if (!block) {
// request more memory
var pagesBefore = current_memory();
var pagesNeeded = ((size + 0xffff) & ~0xffff) >>> 16;
var pagesWanted = max(pagesBefore, pagesNeeded); // double memory
let pagesBefore = current_memory();
let pagesNeeded = ((size + 0xffff) & ~0xffff) >>> 16;
let pagesWanted = max(pagesBefore, pagesNeeded); // double memory
if (grow_memory(pagesWanted) < 0) {
if (grow_memory(pagesNeeded) < 0) {
unreachable(); // out of memory
}
}
var pagesAfter = current_memory();
let pagesAfter = current_memory();
root.addMemory(<usize>pagesBefore << 16, <usize>pagesAfter << 16);
block = assert(root.search(size)); // must be found now
}
@ -486,10 +486,10 @@ export function allocate_memory(size: usize): usize {
@global
export function free_memory(data: usize): void {
if (data) {
var root = ROOT;
let root = ROOT;
if (root) {
var block = changetype<Block>(data - Block.INFO);
var blockInfo = block.info;
let block = changetype<Block>(data - Block.INFO);
let blockInfo = block.info;
assert(!(blockInfo & FREE)); // must be used
block.info = blockInfo | FREE;
root.insert(changetype<Block>(data - Block.INFO));

8
std/assembly/array.ts
View File

@ -124,9 +124,9 @@ export class Array<T> {
var oldCapacity = this.__capacity;
if (this.__length == oldCapacity) {
// inlined __grow (avoids moving twice)
var newCapacity: i32 = oldCapacity ? oldCapacity << 1 : 1;
let newCapacity: i32 = oldCapacity ? oldCapacity << 1 : 1;
assert(newCapacity > this.__capacity);
var newMemory = allocate_memory(<usize>newCapacity * sizeof<T>());
let newMemory = allocate_memory(<usize>newCapacity * sizeof<T>());
if (this.__memory) {
move_memory(
newMemory + sizeof<T>(),
@ -202,8 +202,8 @@ export class Array<T> {
}
reverse(): Array<T> {
for (var front: usize = 0, back: usize = <usize>this.__length - 1; front < back; ++front, --back) {
var temp = load<T>(this.__memory + front * sizeof<T>());
for (let front: usize = 0, back: usize = <usize>this.__length - 1; front < back; ++front, --back) {
let temp = load<T>(this.__memory + front * sizeof<T>());
store<T>(this.__memory + front * sizeof<T>(), load<T>(this.__memory + back * sizeof<T>()));
store<T>(this.__memory + back * sizeof<T>(), temp);
}

4
std/assembly/map.ts
View File

@ -11,7 +11,7 @@ export class Map<K,V> {
get(key: K): V | null {
var keys = this.__keys;
for (var i = 0, k = keys.length; i < k; ++i) {
for (let i = 0, k = keys.length; i < k; ++i) {
if (keys[i] == key) {
return this.__values[i];
}
@ -21,7 +21,7 @@ export class Map<K,V> {
has(key: K): bool {
var keys = this.__keys;
for (var i = 0, k = keys.length; i < k; ++i) {
for (let i = 0, k = keys.length; i < k; ++i) {
if (keys[i] == key) {
return true;
}

6
std/assembly/polyfills.ts
View File

@ -9,9 +9,9 @@ export function bswap<T>(value: T): T {
rotr<u32>(<u32>value & 0x00FF00FF, 8)
);
} else if (sizeof<T>() == 8) {
var a: u64 = (<u64>value >> 8) & 0x00FF00FF00FF00FF;
var b: u64 = (<u64>value & 0x00FF00FF00FF00FF) << 8;
var v: u64 = a | b;
let a: u64 = (<u64>value >> 8) & 0x00FF00FF00FF00FF;
let b: u64 = (<u64>value & 0x00FF00FF00FF00FF) << 8;
let v: u64 = a | b;
a = (v >> 16) & 0x0000FFFF0000FFFF;
b = (v & 0x0000FFFF0000FFFF) << 16;

8
std/assembly/set.ts
View File

@ -21,7 +21,7 @@ export class Set<T> {
has(value: T): bool {
assert(this != null);
for (var index: usize = 0, limit: usize = this.__size; index < limit; ++index) {
for (let index: usize = 0, limit: usize = this.__size; index < limit; ++index) {
if (load<T>(this.__memory + index * sizeof<T>()) == value) {
return true;
}
@ -33,8 +33,8 @@ export class Set<T> {
assert(this != null);
if (this.__size >= this.__capacity) {
var newCapacity = max(this.__capacity << 1, 8);
var newMemory = allocate_memory(<usize>newCapacity * sizeof<T>());
let newCapacity = max(this.__capacity << 1, 8);
let newMemory = allocate_memory(<usize>newCapacity * sizeof<T>());
if (this.__memory) {
move_memory(newMemory, this.__memory, <usize>this.__capacity * sizeof<T>());
free_memory(this.__memory);
@ -50,7 +50,7 @@ export class Set<T> {
delete(value: T): bool {
assert(this != null);
for (var index: usize = 0, limit: usize = this.__size; index < limit; ++index) {
for (let index: usize = 0, limit: usize = this.__size; index < limit; ++index) {
if (load<T>(this.__memory + index * sizeof<T>()) == value) {
if (index + 1 < limit) {
move_memory(

4
std/assembly/string.ts
View File

@ -152,7 +152,7 @@ export class String {
var searchLen: isize = <isize>searchString.length;
// TODO: two-way, multiple char codes
for (var k: usize = start; <isize>k + searchLen <= len; ++k) {
for (let k: usize = start; <isize>k + searchLen <= len; ++k) {
if (!compare_memory(
changetype<usize>(this) + HEAD + (k << 1),
changetype<usize>(searchString) + HEAD,
@ -486,7 +486,7 @@ export function parseFloat(str: String): f64 {
code = <i32>load<u16>(ptr, HEAD);
if (code == CharCode.DOT) {
ptr += 2;
var fac: f64 = 0.1; // precision :(
let fac: f64 = 0.1; // precision :(
while (len--) {
code = <i32>load<u16>(ptr, HEAD);
if (code == CharCode.E || code == CharCode.e) {

5
tests/compiler/std/allocator_arena.untouched.wat
View File

@ -27,7 +27,6 @@
(local $4 i32)
(local $5 i32)
(local $6 i32)
(local $7 i32)
(if
(i32.eqz
(get_local $0)
@ -84,7 +83,7 @@
(i32.const 16)
)
)
(set_local $7
(set_local $5
(select
(tee_local $5
(get_local $3)
@ -101,7 +100,7 @@
(if
(i32.lt_s
(grow_memory
(get_local $7)
(get_local $5)
)
(i32.const 0)
)

16
tests/compiler/std/array.optimized.wat
View File

@ -2164,7 +2164,7 @@
(block
(if
(i32.le_s
(tee_local $3
(tee_local $4
(select
(i32.shl
(get_local $2)
@ -2188,10 +2188,10 @@
(unreachable)
)
)
(set_local $4
(set_local $3
(call "$(lib)/allocator/arena/allocate_memory"
(i32.shl
(get_local $3)
(get_local $4)
(i32.const 2)
)
)
@ -2203,7 +2203,7 @@
(block
(call "$(lib)/memory/move_memory"
(i32.add
(get_local $4)
(get_local $3)
(i32.const 4)
)
(i32.load
@ -2223,11 +2223,11 @@
)
(i32.store
(get_local $0)
(get_local $4)
(get_local $3)
)
(i32.store offset=4
(get_local $0)
(get_local $3)
(get_local $4)
)
)
(call "$(lib)/memory/move_memory"
@ -2254,7 +2254,7 @@
)
(i32.store offset=8
(get_local $0)
(tee_local $0
(tee_local $3
(i32.add
(i32.load offset=8
(get_local $0)
@ -2263,7 +2263,7 @@
)
)
)
(get_local $0)
(get_local $3)
)
(func "$(lib)/memory/set_memory" (; 11 ;) (type $iiiv) (param $0 i32) (param $1 i32) (param $2 i32)
(local $3 i64)

12
tests/compiler/std/array.untouched.wat
View File

@ -29,7 +29,6 @@
(local $4 i32)
(local $5 i32)
(local $6 i32)
(local $7 i32)
(if
(i32.eqz
(get_local $0)
@ -86,7 +85,7 @@
(i32.const 16)
)
)
(set_local $7
(set_local $5
(select
(tee_local $5
(get_local $3)
@ -103,7 +102,7 @@
(if
(i32.lt_s
(grow_memory
(get_local $7)
(get_local $5)
)
(i32.const 0)
)
@ -2449,7 +2448,6 @@
(local $2 i32)
(local $3 i32)
(local $4 i32)
(local $5 i32)
(set_local $2
(i32.load offset=4
(get_local $0)
@ -2558,7 +2556,7 @@
)
(return
(block (result i32)
(set_local $5
(set_local $4
(i32.add
(i32.load offset=8
(get_local $0)
@ -2568,9 +2566,9 @@
)
(i32.store offset=8
(get_local $0)
(get_local $5)
(get_local $4)
)
(get_local $5)
(get_local $4)
)
)
)

5
tests/compiler/std/new.untouched.wat
View File

@ -19,7 +19,6 @@
(local $4 i32)
(local $5 i32)
(local $6 i32)
(local $7 i32)
(if
(i32.eqz
(get_local $0)
@ -76,7 +75,7 @@
(i32.const 16)
)
)
(set_local $7
(set_local $5
(select
(tee_local $5
(get_local $3)
@ -93,7 +92,7 @@
(if
(i32.lt_s
(grow_memory
(get_local $7)
(get_local $5)
)
(i32.const 0)
)

6
tests/compiler/std/set.optimized.wat
View File

@ -2002,7 +2002,7 @@
(i32.shl
(tee_local $3
(select
(tee_local $2
(tee_local $3
(i32.shl
(i32.load offset=4
(get_local $0)
@ -2010,12 +2010,12 @@
(i32.const 1)
)
)
(tee_local $3
(tee_local $2
(i32.const 8)
)
(i32.gt_u
(get_local $2)
(get_local $3)
(get_local $2)
)
)
)

19
tests/compiler/std/set.untouched.wat
View File

@ -25,7 +25,6 @@
(local $4 i32)
(local $5 i32)
(local $6 i32)
(local $7 i32)
(if
(i32.eqz
(get_local $0)
@ -82,7 +81,7 @@
(i32.const 16)
)
)
(set_local $7
(set_local $5
(select
(tee_local $5
(get_local $3)
@ -99,7 +98,7 @@
(if
(i32.lt_s
(grow_memory
(get_local $7)
(get_local $5)
)
(i32.const 0)
)
@ -2260,8 +2259,6 @@
(func "$(lib)/set/Set#add" (; 6 ;) (type $iii) (param $0 i32) (param $1 i32) (result i32)
(local $2 i32)
(local $3 i32)
(local $4 i32)
(local $5 i32)
(if
(i32.eqz
(i32.ne
@ -2289,7 +2286,7 @@
)
)
(block
(set_local $4
(set_local $2
(select
(tee_local $2
(i32.shl
@ -2308,10 +2305,10 @@
)
)
)
(set_local $5
(set_local $3
(call "$(lib)/allocator/arena/allocate_memory"
(i32.mul
(get_local $4)
(get_local $2)
(i32.const 4)
)
)
@ -2322,7 +2319,7 @@
)
(block
(call "$(lib)/memory/move_memory"
(get_local $5)
(get_local $3)
(i32.load
(get_local $0)
)
@ -2342,11 +2339,11 @@
)
(i32.store offset=4
(get_local $0)
(get_local $4)
(get_local $2)
)
(i32.store
(get_local $0)
(get_local $5)
(get_local $3)
)
)
)

3
tslint.json
View File

@ -6,8 +6,11 @@
"defaultSeverity": "warning",
"rules": {
"as-types": { "severity": "error" },
"as-variables": true,
"as-internal-case": true,
"as-internal-diagnostics": true,
"adjacent-overload-signatures": true,
"ban-types": [ true, ["Object"], ["any"], ["undefined"], ["never"] ],
"curly": [true, "ignore-same-line"],