SQL Operations Studio Public Preview 1 (0.23) release source code

build/lib/tslint/allowAsyncRule.js

@@ -0,0 +1,59 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts = require("typescript");
+var Lint = require("tslint");
+var Rule = (function (_super) {
+    __extends(Rule, _super);
+    function Rule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Rule.prototype.apply = function (sourceFile) {
+        var allowed = this.getOptions().ruleArguments[0];
+        return this.applyWithWalker(new AsyncRuleWalker(sourceFile, this.getOptions(), allowed));
+    };
+    return Rule;
+}(Lint.Rules.AbstractRule));
+exports.Rule = Rule;
+var AsyncRuleWalker = (function (_super) {
+    __extends(AsyncRuleWalker, _super);
+    function AsyncRuleWalker(file, opts, allowed) {
+        var _this = _super.call(this, file, opts) || this;
+        _this.allowed = allowed;
+        return _this;
+    }
+    AsyncRuleWalker.prototype.visitMethodDeclaration = function (node) {
+        this.visitFunctionLikeDeclaration(node);
+    };
+    AsyncRuleWalker.prototype.visitFunctionDeclaration = function (node) {
+        this.visitFunctionLikeDeclaration(node);
+    };
+    AsyncRuleWalker.prototype.visitFunctionLikeDeclaration = function (node) {
+        var _this = this;
+        var flags = ts.getCombinedModifierFlags(node);
+        if (!(flags & ts.ModifierFlags.Async)) {
+            return;
+        }
+        var path = node.getSourceFile().path;
+        var pathParts = path.split(/\\|\//);
+        if (pathParts.some(function (part) { return _this.allowed.some(function (allowed) { return part === allowed; }); })) {
+            return;
+        }
+        var message = "You are not allowed to use async function in this layer. Allowed layers are: [" + this.allowed + "]";
+        this.addFailureAtNode(node, message);
+    };
+    return AsyncRuleWalker;
+}(Lint.RuleWalker));

build/lib/tslint/allowAsyncRule.ts

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as ts from 'typescript';
+import * as Lint from 'tslint';
+
+export class Rule extends Lint.Rules.AbstractRule {
+	public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+		const allowed = this.getOptions().ruleArguments[0] as string[];
+		return this.applyWithWalker(new AsyncRuleWalker(sourceFile, this.getOptions(), allowed));
+	}
+}
+
+class AsyncRuleWalker extends Lint.RuleWalker {
+
+	constructor(file: ts.SourceFile, opts: Lint.IOptions, private allowed: string[]) {
+		super(file, opts);
+	}
+
+	protected visitMethodDeclaration(node: ts.MethodDeclaration): void {
+		this.visitFunctionLikeDeclaration(node);
+	}
+
+	protected visitFunctionDeclaration(node: ts.FunctionDeclaration): void {
+		this.visitFunctionLikeDeclaration(node);
+	}
+
+	private visitFunctionLikeDeclaration(node: ts.FunctionLikeDeclaration) {
+		const flags = ts.getCombinedModifierFlags(node);
+
+		if (!(flags & ts.ModifierFlags.Async)) {
+			return;
+		}
+
+		const path = (node.getSourceFile() as any).path;
+		const pathParts = path.split(/\\|\//);
+
+		if (pathParts.some(part => this.allowed.some(allowed => part === allowed))) {
+			return;
+		}
+
+		const message = `You are not allowed to use async function in this layer. Allowed layers are: [${this.allowed}]`;
+		this.addFailureAtNode(node, message);
+	}
+}

build/lib/tslint/duplicateImportsRule.js

@@ -0,0 +1,50 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = require("path");
+var Lint = require("tslint");
+var Rule = (function (_super) {
+    __extends(Rule, _super);
+    function Rule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Rule.prototype.apply = function (sourceFile) {
+        return this.applyWithWalker(new ImportPatterns(sourceFile, this.getOptions()));
+    };
+    return Rule;
+}(Lint.Rules.AbstractRule));
+exports.Rule = Rule;
+var ImportPatterns = (function (_super) {
+    __extends(ImportPatterns, _super);
+    function ImportPatterns(file, opts) {
+        var _this = _super.call(this, file, opts) || this;
+        _this.imports = Object.create(null);
+        return _this;
+    }
+    ImportPatterns.prototype.visitImportDeclaration = function (node) {
+        var path = node.moduleSpecifier.getText();
+        // remove quotes
+        path = path.slice(1, -1);
+        if (path[0] === '.') {
+            path = path_1.join(path_1.dirname(node.getSourceFile().fileName), path);
+        }
+        if (this.imports[path]) {
+            this.addFailure(this.createFailure(node.getStart(), node.getWidth(), "Duplicate imports for '" + path + "'."));
+        }
+        this.imports[path] = true;
+    };
+    return ImportPatterns;
+}(Lint.RuleWalker));

build/lib/tslint/duplicateImportsRule.ts

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as ts from 'typescript';
+import { join, dirname } from 'path';
+import * as Lint from 'tslint';
+
+export class Rule extends Lint.Rules.AbstractRule {
+	public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+		return this.applyWithWalker(new ImportPatterns(sourceFile, this.getOptions()));
+	}
+}
+
+class ImportPatterns extends Lint.RuleWalker {
+
+	private imports: { [path: string]: boolean; } = Object.create(null);
+
+	constructor(file: ts.SourceFile, opts: Lint.IOptions) {
+		super(file, opts);
+	}
+
+	protected visitImportDeclaration(node: ts.ImportDeclaration): void {
+		let path = node.moduleSpecifier.getText();
+
+		// remove quotes
+		path = path.slice(1, -1);
+
+		if (path[0] === '.') {
+			path = join(dirname(node.getSourceFile().fileName), path);
+		}
+
+		if (this.imports[path]) {
+			this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Duplicate imports for '${path}'.`));
+		}
+
+		this.imports[path] = true;
+	}
+}

build/lib/tslint/importPatternsRule.js

@@ -0,0 +1,90 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts = require("typescript");
+var Lint = require("tslint");
+var minimatch = require("minimatch");
+var path_1 = require("path");
+var Rule = (function (_super) {
+    __extends(Rule, _super);
+    function Rule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Rule.prototype.apply = function (sourceFile) {
+        var configs = this.getOptions().ruleArguments;
+        for (var _i = 0, configs_1 = configs; _i < configs_1.length; _i++) {
+            var config = configs_1[_i];
+            if (minimatch(sourceFile.fileName, config.target)) {
+                return this.applyWithWalker(new ImportPatterns(sourceFile, this.getOptions(), config));
+            }
+        }
+        return [];
+    };
+    return Rule;
+}(Lint.Rules.AbstractRule));
+exports.Rule = Rule;
+var ImportPatterns = (function (_super) {
+    __extends(ImportPatterns, _super);
+    function ImportPatterns(file, opts, _config) {
+        var _this = _super.call(this, file, opts) || this;
+        _this._config = _config;
+        return _this;
+    }
+    ImportPatterns.prototype.visitImportEqualsDeclaration = function (node) {
+        if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
+            this._validateImport(node.moduleReference.expression.getText(), node);
+        }
+    };
+    ImportPatterns.prototype.visitImportDeclaration = function (node) {
+        this._validateImport(node.moduleSpecifier.getText(), node);
+    };
+    ImportPatterns.prototype.visitCallExpression = function (node) {
+        _super.prototype.visitCallExpression.call(this, node);
+        // import('foo') statements inside the code
+        if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+            var path = node.arguments[0];
+            this._validateImport(path.getText(), node);
+        }
+    };
+    ImportPatterns.prototype._validateImport = function (path, node) {
+        // remove quotes
+        path = path.slice(1, -1);
+        // resolve relative paths
+        if (path[0] === '.') {
+            path = path_1.join(this.getSourceFile().fileName, path);
+        }
+        var restrictions;
+        if (typeof this._config.restrictions === 'string') {
+            restrictions = [this._config.restrictions];
+        }
+        else {
+            restrictions = this._config.restrictions;
+        }
+        var matched = false;
+        for (var _i = 0, restrictions_1 = restrictions; _i < restrictions_1.length; _i++) {
+            var pattern = restrictions_1[_i];
+            if (minimatch(path, pattern)) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            // None of the restrictions matched
+            this.addFailure(this.createFailure(node.getStart(), node.getWidth(), "Imports violates '" + restrictions.join(' or ') + "' restrictions. See https://github.com/Microsoft/vscode/wiki/Code-Organization"));
+        }
+    };
+    return ImportPatterns;
+}(Lint.RuleWalker));

build/lib/tslint/importPatternsRule.ts

@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as ts from 'typescript';
+import * as Lint from 'tslint';
+import * as minimatch from 'minimatch';
+import { join } from 'path';
+
+interface ImportPatternsConfig {
+	target: string;
+	restrictions: string | string[];
+}
+
+export class Rule extends Lint.Rules.AbstractRule {
+	public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+
+		const configs = <ImportPatternsConfig[]>this.getOptions().ruleArguments;
+
+
+		for (const config of configs) {
+			if (minimatch(sourceFile.fileName, config.target)) {
+				return this.applyWithWalker(new ImportPatterns(sourceFile, this.getOptions(), config));
+			}
+		}
+
+		return [];
+	}
+}
+
+class ImportPatterns extends Lint.RuleWalker {
+
+	constructor(file: ts.SourceFile, opts: Lint.IOptions, private _config: ImportPatternsConfig) {
+		super(file, opts);
+	}
+
+	protected visitImportEqualsDeclaration(node: ts.ImportEqualsDeclaration): void {
+		if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
+			this._validateImport(node.moduleReference.expression.getText(), node);
+		}
+	}
+
+	protected visitImportDeclaration(node: ts.ImportDeclaration): void {
+		this._validateImport(node.moduleSpecifier.getText(), node);
+	}
+
+	protected visitCallExpression(node: ts.CallExpression): void {
+		super.visitCallExpression(node);
+
+		// import('foo') statements inside the code
+		if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+			const [path] = node.arguments;
+			this._validateImport(path.getText(), node);
+		}
+	}
+
+	private _validateImport(path: string, node: ts.Node): void {
+		// remove quotes
+		path = path.slice(1, -1);
+
+		// resolve relative paths
+		if (path[0] === '.') {
+			path = join(this.getSourceFile().fileName, path);
+		}
+
+		let restrictions: string[];
+		if (typeof this._config.restrictions === 'string') {
+			restrictions = [this._config.restrictions];
+		} else {
+			restrictions = this._config.restrictions;
+		}
+
+		let matched = false;
+		for (const pattern of restrictions) {
+			if (minimatch(path, pattern)) {
+				matched = true;
+				break;
+			}
+		}
+
+		if (!matched) {
+			// None of the restrictions matched
+			this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Imports violates '${restrictions.join(' or ')}' restrictions. See https://github.com/Microsoft/vscode/wiki/Code-Organization`));
+		}
+	}
+}

build/lib/tslint/layeringRule.js

@@ -0,0 +1,101 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts = require("typescript");
+var Lint = require("tslint");
+var path_1 = require("path");
+var Rule = (function (_super) {
+    __extends(Rule, _super);
+    function Rule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Rule.prototype.apply = function (sourceFile) {
+        var parts = path_1.dirname(sourceFile.fileName).split(/\\|\//);
+        var ruleArgs = this.getOptions().ruleArguments[0];
+        var config;
+        for (var i = parts.length - 1; i >= 0; i--) {
+            if (ruleArgs[parts[i]]) {
+                config = {
+                    allowed: new Set(ruleArgs[parts[i]]).add(parts[i]),
+                    disallowed: new Set()
+                };
+                Object.keys(ruleArgs).forEach(function (key) {
+                    if (!config.allowed.has(key)) {
+                        config.disallowed.add(key);
+                    }
+                });
+                break;
+            }
+        }
+        if (!config) {
+            return [];
+        }
+        return this.applyWithWalker(new LayeringRule(sourceFile, config, this.getOptions()));
+    };
+    return Rule;
+}(Lint.Rules.AbstractRule));
+exports.Rule = Rule;
+var LayeringRule = (function (_super) {
+    __extends(LayeringRule, _super);
+    function LayeringRule(file, config, opts) {
+        var _this = _super.call(this, file, opts) || this;
+        _this._config = config;
+        return _this;
+    }
+    LayeringRule.prototype.visitImportEqualsDeclaration = function (node) {
+        if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
+            this._validateImport(node.moduleReference.expression.getText(), node);
+        }
+    };
+    LayeringRule.prototype.visitImportDeclaration = function (node) {
+        this._validateImport(node.moduleSpecifier.getText(), node);
+    };
+    LayeringRule.prototype.visitCallExpression = function (node) {
+        _super.prototype.visitCallExpression.call(this, node);
+        // import('foo') statements inside the code
+        if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+            var path = node.arguments[0];
+            this._validateImport(path.getText(), node);
+        }
+    };
+    LayeringRule.prototype._validateImport = function (path, node) {
+        // remove quotes
+        path = path.slice(1, -1);
+        if (path[0] === '.') {
+            path = path_1.join(path_1.dirname(node.getSourceFile().fileName), path);
+        }
+        var parts = path_1.dirname(path).split(/\\|\//);
+        for (var i = parts.length - 1; i >= 0; i--) {
+            var part = parts[i];
+            if (this._config.allowed.has(part)) {
+                // GOOD - same layer
+                return;
+            }
+            if (this._config.disallowed.has(part)) {
+                // BAD - wrong layer
+                var message = "Bad layering. You are not allowed to access '" + part + "' from here, allowed layers are: [" + LayeringRule._print(this._config.allowed) + "]";
+                this.addFailure(this.createFailure(node.getStart(), node.getWidth(), message));
+                return;
+            }
+        }
+    };
+    LayeringRule._print = function (set) {
+        var r = [];
+        set.forEach(function (e) { return r.push(e); });
+        return r.join(', ');
+    };
+    return LayeringRule;
+}(Lint.RuleWalker));

build/lib/tslint/layeringRule.ts

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as ts from 'typescript';
+import * as Lint from 'tslint';
+import { join, dirname } from 'path';
+
+interface Config {
+	allowed: Set<string>;
+	disallowed: Set<string>;
+}
+
+export class Rule extends Lint.Rules.AbstractRule {
+	public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+
+		const parts = dirname(sourceFile.fileName).split(/\\|\//);
+		let ruleArgs = this.getOptions().ruleArguments[0];
+
+		let config: Config;
+		for (let i = parts.length - 1; i >= 0; i--) {
+			if (ruleArgs[parts[i]]) {
+				config = {
+					allowed: new Set<string>(<string[]>ruleArgs[parts[i]]).add(parts[i]),
+					disallowed: new Set<string>()
+				};
+				Object.keys(ruleArgs).forEach(key => {
+					if (!config.allowed.has(key)) {
+						config.disallowed.add(key);
+					}
+				});
+				break;
+			}
+		}
+
+		if (!config) {
+			return [];
+		}
+
+		return this.applyWithWalker(new LayeringRule(sourceFile, config, this.getOptions()));
+	}
+}
+
+class LayeringRule extends Lint.RuleWalker {
+
+	private _config: Config;
+
+	constructor(file: ts.SourceFile, config: Config, opts: Lint.IOptions) {
+		super(file, opts);
+		this._config = config;
+	}
+
+	protected visitImportEqualsDeclaration(node: ts.ImportEqualsDeclaration): void {
+		if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
+			this._validateImport(node.moduleReference.expression.getText(), node);
+		}
+	}
+
+	protected visitImportDeclaration(node: ts.ImportDeclaration): void {
+		this._validateImport(node.moduleSpecifier.getText(), node);
+	}
+
+	protected visitCallExpression(node: ts.CallExpression): void {
+		super.visitCallExpression(node);
+
+		// import('foo') statements inside the code
+		if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+			const [path] = node.arguments;
+			this._validateImport(path.getText(), node);
+		}
+	}
+
+	private _validateImport(path: string, node: ts.Node): void {
+		// remove quotes
+		path = path.slice(1, -1);
+
+		if (path[0] === '.') {
+			path = join(dirname(node.getSourceFile().fileName), path);
+		}
+
+		const parts = dirname(path).split(/\\|\//);
+		for (let i = parts.length - 1; i >= 0; i--) {
+			const part = parts[i];
+
+			if (this._config.allowed.has(part)) {
+				// GOOD - same layer
+				return;
+			}
+
+			if (this._config.disallowed.has(part)) {
+				// BAD - wrong layer
+				const message = `Bad layering. You are not allowed to access '${part}' from here, allowed layers are: [${LayeringRule._print(this._config.allowed)}]`;
+				this.addFailure(this.createFailure(node.getStart(), node.getWidth(), message));
+				return;
+			}
+		}
+	}
+
+	static _print(set: Set<string>): string {
+		let r: string[] = [];
+		set.forEach(e => r.push(e));
+		return r.join(', ');
+	}
+}

build/lib/tslint/noUnexternalizedStringsRule.js

@@ -0,0 +1,182 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var ts = require("typescript");
+var Lint = require("tslint");
+/**
+ * Implementation of the no-unexternalized-strings rule.
+ */
+var Rule = (function (_super) {
+    __extends(Rule, _super);
+    function Rule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Rule.prototype.apply = function (sourceFile) {
+        return this.applyWithWalker(new NoUnexternalizedStringsRuleWalker(sourceFile, this.getOptions()));
+    };
+    return Rule;
+}(Lint.Rules.AbstractRule));
+exports.Rule = Rule;
+function isStringLiteral(node) {
+    return node && node.kind === ts.SyntaxKind.StringLiteral;
+}
+function isObjectLiteral(node) {
+    return node && node.kind === ts.SyntaxKind.ObjectLiteralExpression;
+}
+function isPropertyAssignment(node) {
+    return node && node.kind === ts.SyntaxKind.PropertyAssignment;
+}
+var NoUnexternalizedStringsRuleWalker = (function (_super) {
+    __extends(NoUnexternalizedStringsRuleWalker, _super);
+    function NoUnexternalizedStringsRuleWalker(file, opts) {
+        var _this = _super.call(this, file, opts) || this;
+        _this.signatures = Object.create(null);
+        _this.ignores = Object.create(null);
+        _this.messageIndex = undefined;
+        _this.keyIndex = undefined;
+        _this.usedKeys = Object.create(null);
+        var options = _this.getOptions();
+        var first = options && options.length > 0 ? options[0] : null;
+        if (first) {
+            if (Array.isArray(first.signatures)) {
+                first.signatures.forEach(function (signature) { return _this.signatures[signature] = true; });
+            }
+            if (Array.isArray(first.ignores)) {
+                first.ignores.forEach(function (ignore) { return _this.ignores[ignore] = true; });
+            }
+            if (typeof first.messageIndex !== 'undefined') {
+                _this.messageIndex = first.messageIndex;
+            }
+            if (typeof first.keyIndex !== 'undefined') {
+                _this.keyIndex = first.keyIndex;
+            }
+        }
+        return _this;
+    }
+    NoUnexternalizedStringsRuleWalker.prototype.visitSourceFile = function (node) {
+        var _this = this;
+        _super.prototype.visitSourceFile.call(this, node);
+        Object.keys(this.usedKeys).forEach(function (key) {
+            var occurrences = _this.usedKeys[key];
+            if (occurrences.length > 1) {
+                occurrences.forEach(function (occurrence) {
+                    _this.addFailure((_this.createFailure(occurrence.key.getStart(), occurrence.key.getWidth(), "Duplicate key " + occurrence.key.getText() + " with different message value.")));
+                });
+            }
+        });
+    };
+    NoUnexternalizedStringsRuleWalker.prototype.visitStringLiteral = function (node) {
+        this.checkStringLiteral(node);
+        _super.prototype.visitStringLiteral.call(this, node);
+    };
+    NoUnexternalizedStringsRuleWalker.prototype.checkStringLiteral = function (node) {
+        var text = node.getText();
+        var doubleQuoted = text.length >= 2 && text[0] === NoUnexternalizedStringsRuleWalker.DOUBLE_QUOTE && text[text.length - 1] === NoUnexternalizedStringsRuleWalker.DOUBLE_QUOTE;
+        var info = this.findDescribingParent(node);
+        // Ignore strings in import and export nodes.
+        if (info && info.isImport && doubleQuoted) {
+            this.addFailureAtNode(node, NoUnexternalizedStringsRuleWalker.ImportFailureMessage, new Lint.Fix(NoUnexternalizedStringsRuleWalker.ImportFailureMessage, [
+                this.createReplacement(node.getStart(), 1, '\''),
+                this.createReplacement(node.getStart() + text.length - 1, 1, '\''),
+            ]));
+            return;
+        }
+        var callInfo = info ? info.callInfo : null;
+        var functionName = callInfo ? callInfo.callExpression.expression.getText() : null;
+        if (functionName && this.ignores[functionName]) {
+            return;
+        }
+        if (doubleQuoted && (!callInfo || callInfo.argIndex === -1 || !this.signatures[functionName])) {
+            var s = node.getText();
+            var replacement = new Lint.Replacement(node.getStart(), node.getWidth(), "nls.localize('KEY-" + s.substring(1, s.length - 1) + "', " + s + ")");
+            var fix = new Lint.Fix('Unexternalitzed string', [replacement]);
+            this.addFailure(this.createFailure(node.getStart(), node.getWidth(), "Unexternalized string found: " + node.getText(), fix));
+            return;
+        }
+        // We have a single quoted string outside a localize function name.
+        if (!doubleQuoted && !this.signatures[functionName]) {
+            return;
+        }
+        // We have a string that is a direct argument into the localize call.
+        var keyArg = callInfo.argIndex === this.keyIndex
+            ? callInfo.callExpression.arguments[this.keyIndex]
+            : null;
+        if (keyArg) {
+            if (isStringLiteral(keyArg)) {
+                this.recordKey(keyArg, this.messageIndex ? callInfo.callExpression.arguments[this.messageIndex] : undefined);
+            }
+            else if (isObjectLiteral(keyArg)) {
+                for (var i = 0; i < keyArg.properties.length; i++) {
+                    var property = keyArg.properties[i];
+                    if (isPropertyAssignment(property)) {
+                        var name_1 = property.name.getText();
+                        if (name_1 === 'key') {
+                            var initializer = property.initializer;
+                            if (isStringLiteral(initializer)) {
+                                this.recordKey(initializer, this.messageIndex ? callInfo.callExpression.arguments[this.messageIndex] : undefined);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        var messageArg = callInfo.argIndex === this.messageIndex
+            ? callInfo.callExpression.arguments[this.messageIndex]
+            : null;
+        if (messageArg && messageArg !== node) {
+            this.addFailure(this.createFailure(messageArg.getStart(), messageArg.getWidth(), "Message argument to '" + callInfo.callExpression.expression.getText() + "' must be a string literal."));
+            return;
+        }
+    };
+    NoUnexternalizedStringsRuleWalker.prototype.recordKey = function (keyNode, messageNode) {
+        var text = keyNode.getText();
+        var occurrences = this.usedKeys[text];
+        if (!occurrences) {
+            occurrences = [];
+            this.usedKeys[text] = occurrences;
+        }
+        if (messageNode) {
+            if (occurrences.some(function (pair) { return pair.message ? pair.message.getText() === messageNode.getText() : false; })) {
+                return;
+            }
+        }
+        occurrences.push({ key: keyNode, message: messageNode });
+    };
+    NoUnexternalizedStringsRuleWalker.prototype.findDescribingParent = function (node) {
+        var parent;
+        while ((parent = node.parent)) {
+            var kind = parent.kind;
+            if (kind === ts.SyntaxKind.CallExpression) {
+                var callExpression = parent;
+                return { callInfo: { callExpression: callExpression, argIndex: callExpression.arguments.indexOf(node) } };
+            }
+            else if (kind === ts.SyntaxKind.ImportEqualsDeclaration || kind === ts.SyntaxKind.ImportDeclaration || kind === ts.SyntaxKind.ExportDeclaration) {
+                return { isImport: true };
+            }
+            else if (kind === ts.SyntaxKind.VariableDeclaration || kind === ts.SyntaxKind.FunctionDeclaration || kind === ts.SyntaxKind.PropertyDeclaration
+                || kind === ts.SyntaxKind.MethodDeclaration || kind === ts.SyntaxKind.VariableDeclarationList || kind === ts.SyntaxKind.InterfaceDeclaration
+                || kind === ts.SyntaxKind.ClassDeclaration || kind === ts.SyntaxKind.EnumDeclaration || kind === ts.SyntaxKind.ModuleDeclaration
+                || kind === ts.SyntaxKind.TypeAliasDeclaration || kind === ts.SyntaxKind.SourceFile) {
+                return null;
+            }
+            node = parent;
+        }
+    };
+    NoUnexternalizedStringsRuleWalker.ImportFailureMessage = 'Do not use double qoutes for imports.';
+    NoUnexternalizedStringsRuleWalker.DOUBLE_QUOTE = '"';
+    return NoUnexternalizedStringsRuleWalker;
+}(Lint.RuleWalker));

build/lib/tslint/noUnexternalizedStringsRule.ts

@@ -0,0 +1,201 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as ts from 'typescript';
+import * as Lint from 'tslint';
+
+/**
+ * Implementation of the no-unexternalized-strings rule.
+ */
+export class Rule extends Lint.Rules.AbstractRule {
+	public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+		return this.applyWithWalker(new NoUnexternalizedStringsRuleWalker(sourceFile, this.getOptions()));
+	}
+}
+
+interface Map<V> {
+	[key: string]: V;
+}
+
+interface UnexternalizedStringsOptions {
+	signatures?: string[];
+	messageIndex?: number;
+	keyIndex?: number;
+	ignores?: string[];
+}
+
+function isStringLiteral(node: ts.Node): node is ts.StringLiteral {
+	return node && node.kind === ts.SyntaxKind.StringLiteral;
+}
+
+function isObjectLiteral(node: ts.Node): node is ts.ObjectLiteralExpression {
+	return node && node.kind === ts.SyntaxKind.ObjectLiteralExpression;
+}
+
+function isPropertyAssignment(node: ts.Node): node is ts.PropertyAssignment {
+	return node && node.kind === ts.SyntaxKind.PropertyAssignment;
+}
+
+interface KeyMessagePair {
+	key: ts.StringLiteral;
+	message: ts.Node;
+}
+
+class NoUnexternalizedStringsRuleWalker extends Lint.RuleWalker {
+
+	private static ImportFailureMessage = 'Do not use double qoutes for imports.';
+
+	private static DOUBLE_QUOTE: string = '"';
+
+	private signatures: Map<boolean>;
+	private messageIndex: number;
+	private keyIndex: number;
+	private ignores: Map<boolean>;
+
+	private usedKeys: Map<KeyMessagePair[]>;
+
+	constructor(file: ts.SourceFile, opts: Lint.IOptions) {
+		super(file, opts);
+		this.signatures = Object.create(null);
+		this.ignores = Object.create(null);
+		this.messageIndex = undefined;
+		this.keyIndex = undefined;
+		this.usedKeys = Object.create(null);
+		let options: any[] = this.getOptions();
+		let first: UnexternalizedStringsOptions = options && options.length > 0 ? options[0] : null;
+		if (first) {
+			if (Array.isArray(first.signatures)) {
+				first.signatures.forEach((signature: string) => this.signatures[signature] = true);
+			}
+			if (Array.isArray(first.ignores)) {
+				first.ignores.forEach((ignore: string) => this.ignores[ignore] = true);
+			}
+			if (typeof first.messageIndex !== 'undefined') {
+				this.messageIndex = first.messageIndex;
+			}
+			if (typeof first.keyIndex !== 'undefined') {
+				this.keyIndex = first.keyIndex;
+			}
+		}
+	}
+
+	protected visitSourceFile(node: ts.SourceFile): void {
+		super.visitSourceFile(node);
+		Object.keys(this.usedKeys).forEach(key => {
+			let occurrences = this.usedKeys[key];
+			if (occurrences.length > 1) {
+				occurrences.forEach(occurrence => {
+					this.addFailure((this.createFailure(occurrence.key.getStart(), occurrence.key.getWidth(), `Duplicate key ${occurrence.key.getText()} with different message value.`)));
+				});
+			}
+		});
+	}
+
+	protected visitStringLiteral(node: ts.StringLiteral): void {
+		this.checkStringLiteral(node);
+		super.visitStringLiteral(node);
+	}
+
+	private checkStringLiteral(node: ts.StringLiteral): void {
+		let text = node.getText();
+		let doubleQuoted = text.length >= 2 && text[0] === NoUnexternalizedStringsRuleWalker.DOUBLE_QUOTE && text[text.length - 1] === NoUnexternalizedStringsRuleWalker.DOUBLE_QUOTE;
+		let info = this.findDescribingParent(node);
+		// Ignore strings in import and export nodes.
+		if (info && info.isImport && doubleQuoted) {
+			this.addFailureAtNode(
+				node,
+				NoUnexternalizedStringsRuleWalker.ImportFailureMessage,
+				new Lint.Fix(NoUnexternalizedStringsRuleWalker.ImportFailureMessage, [
+					this.createReplacement(node.getStart(), 1, '\''),
+					this.createReplacement(node.getStart() + text.length - 1, 1, '\''),
+				])
+			);
+			return;
+		}
+		let callInfo = info ? info.callInfo : null;
+		let functionName = callInfo ? callInfo.callExpression.expression.getText() : null;
+		if (functionName && this.ignores[functionName]) {
+			return;
+		}
+
+		if (doubleQuoted && (!callInfo || callInfo.argIndex === -1 || !this.signatures[functionName])) {
+			const s = node.getText();
+			const replacement = new Lint.Replacement(node.getStart(), node.getWidth(), `nls.localize('KEY-${s.substring(1, s.length - 1)}', ${s})`);
+			const fix = new Lint.Fix('Unexternalitzed string', [replacement]);
+			this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Unexternalized string found: ${node.getText()}`, fix));
+			return;
+		}
+		// We have a single quoted string outside a localize function name.
+		if (!doubleQuoted && !this.signatures[functionName]) {
+			return;
+		}
+		// We have a string that is a direct argument into the localize call.
+		let keyArg: ts.Expression = callInfo.argIndex === this.keyIndex
+			? callInfo.callExpression.arguments[this.keyIndex]
+			: null;
+		if (keyArg) {
+			if (isStringLiteral(keyArg)) {
+				this.recordKey(keyArg, this.messageIndex ? callInfo.callExpression.arguments[this.messageIndex] : undefined);
+			} else if (isObjectLiteral(keyArg)) {
+				for (let i = 0; i < keyArg.properties.length; i++) {
+					let property = keyArg.properties[i];
+					if (isPropertyAssignment(property)) {
+						let name = property.name.getText();
+						if (name === 'key') {
+							let initializer = property.initializer;
+							if (isStringLiteral(initializer)) {
+								this.recordKey(initializer, this.messageIndex ? callInfo.callExpression.arguments[this.messageIndex] : undefined);
+							}
+							break;
+						}
+					}
+				}
+			}
+		}
+		let messageArg: ts.Expression = callInfo.argIndex === this.messageIndex
+			? callInfo.callExpression.arguments[this.messageIndex]
+			: null;
+		if (messageArg && messageArg !== node) {
+			this.addFailure(this.createFailure(
+				messageArg.getStart(), messageArg.getWidth(),
+				`Message argument to '${callInfo.callExpression.expression.getText()}' must be a string literal.`));
+			return;
+		}
+	}
+
+	private recordKey(keyNode: ts.StringLiteral, messageNode: ts.Node) {
+		let text = keyNode.getText();
+		let occurrences: KeyMessagePair[] = this.usedKeys[text];
+		if (!occurrences) {
+			occurrences = [];
+			this.usedKeys[text] = occurrences;
+		}
+		if (messageNode) {
+			if (occurrences.some(pair => pair.message ? pair.message.getText() === messageNode.getText() : false)) {
+				return;
+			}
+		}
+		occurrences.push({ key: keyNode, message: messageNode });
+	}
+
+	private findDescribingParent(node: ts.Node): { callInfo?: { callExpression: ts.CallExpression, argIndex: number }, isImport?: boolean; } {
+		let parent: ts.Node;
+		while ((parent = node.parent)) {
+			let kind = parent.kind;
+			if (kind === ts.SyntaxKind.CallExpression) {
+				let callExpression = parent as ts.CallExpression;
+				return { callInfo: { callExpression: callExpression, argIndex: callExpression.arguments.indexOf(<any>node) } };
+			} else if (kind === ts.SyntaxKind.ImportEqualsDeclaration || kind === ts.SyntaxKind.ImportDeclaration || kind === ts.SyntaxKind.ExportDeclaration) {
+				return { isImport: true };
+			} else if (kind === ts.SyntaxKind.VariableDeclaration || kind === ts.SyntaxKind.FunctionDeclaration || kind === ts.SyntaxKind.PropertyDeclaration
+				|| kind === ts.SyntaxKind.MethodDeclaration || kind === ts.SyntaxKind.VariableDeclarationList || kind === ts.SyntaxKind.InterfaceDeclaration
+				|| kind === ts.SyntaxKind.ClassDeclaration || kind === ts.SyntaxKind.EnumDeclaration || kind === ts.SyntaxKind.ModuleDeclaration
+				|| kind === ts.SyntaxKind.TypeAliasDeclaration || kind === ts.SyntaxKind.SourceFile) {
+				return null;
+			}
+			node = parent;
+		}
+	}
+}

build/lib/tslint/translationRemindRule.js

@@ -0,0 +1,79 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var Lint = require("tslint");
+var fs = require("fs");
+var Rule = (function (_super) {
+    __extends(Rule, _super);
+    function Rule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Rule.prototype.apply = function (sourceFile) {
+        return this.applyWithWalker(new TranslationRemindRuleWalker(sourceFile, this.getOptions()));
+    };
+    return Rule;
+}(Lint.Rules.AbstractRule));
+exports.Rule = Rule;
+var TranslationRemindRuleWalker = (function (_super) {
+    __extends(TranslationRemindRuleWalker, _super);
+    function TranslationRemindRuleWalker(file, opts) {
+        return _super.call(this, file, opts) || this;
+    }
+    TranslationRemindRuleWalker.prototype.visitImportDeclaration = function (node) {
+        var declaration = node.moduleSpecifier.getText();
+        if (declaration !== "'" + TranslationRemindRuleWalker.NLS_MODULE + "'") {
+            return;
+        }
+        this.visitImportLikeDeclaration(node);
+    };
+    TranslationRemindRuleWalker.prototype.visitImportEqualsDeclaration = function (node) {
+        var reference = node.moduleReference.getText();
+        if (reference !== "require('" + TranslationRemindRuleWalker.NLS_MODULE + "')") {
+            return;
+        }
+        this.visitImportLikeDeclaration(node);
+    };
+    TranslationRemindRuleWalker.prototype.visitImportLikeDeclaration = function (node) {
+        var currentFile = node.getSourceFile().fileName;
+        var matchService = currentFile.match(/vs\/workbench\/services\/\w+/);
+        var matchPart = currentFile.match(/vs\/workbench\/parts\/\w+/);
+        if (!matchService && !matchPart) {
+            return;
+        }
+        var resource = matchService ? matchService[0] : matchPart[0];
+        var resourceDefined = false;
+        var json;
+        try {
+            json = fs.readFileSync('./build/lib/i18n.resources.json', 'utf8');
+        }
+        catch (e) {
+            console.error('[translation-remind rule]: File with resources to pull from Transifex was not found. Aborting translation resource check for newly defined workbench part/service.');
+            return;
+        }
+        var workbenchResources = JSON.parse(json).workbench;
+        workbenchResources.forEach(function (existingResource) {
+            if (existingResource.name === resource) {
+                resourceDefined = true;
+                return;
+            }
+        });
+        if (!resourceDefined) {
+            this.addFailureAtNode(node, "Please add '" + resource + "' to ./builds/lib/i18n.resources.json file to use translations here.");
+        }
+    };
+    TranslationRemindRuleWalker.NLS_MODULE = 'vs/nls';
+    return TranslationRemindRuleWalker;
+}(Lint.RuleWalker));

build/lib/tslint/translationRemindRule.ts

@@ -0,0 +1,73 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as ts from 'typescript';
+import * as Lint from 'tslint';
+import * as fs from 'fs';
+
+export class Rule extends Lint.Rules.AbstractRule {
+	public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+		return this.applyWithWalker(new TranslationRemindRuleWalker(sourceFile, this.getOptions()));
+	}
+}
+
+class TranslationRemindRuleWalker extends Lint.RuleWalker {
+
+	private static NLS_MODULE: string = 'vs/nls';
+
+	constructor(file: ts.SourceFile, opts: Lint.IOptions) {
+		super(file, opts);
+	}
+
+	protected visitImportDeclaration(node: ts.ImportDeclaration): void {
+		const declaration = node.moduleSpecifier.getText();
+		if (declaration !== `'${TranslationRemindRuleWalker.NLS_MODULE}'`) {
+			return;
+		}
+
+		this.visitImportLikeDeclaration(node);
+	}
+
+    protected visitImportEqualsDeclaration(node: ts.ImportEqualsDeclaration): void {
+		const reference = node.moduleReference.getText();
+		if (reference !== `require('${TranslationRemindRuleWalker.NLS_MODULE}')`) {
+			return;
+		}
+
+		this.visitImportLikeDeclaration(node);
+	}
+
+	private visitImportLikeDeclaration(node: ts.ImportDeclaration | ts.ImportEqualsDeclaration) {
+		const currentFile = node.getSourceFile().fileName;
+		const matchService = currentFile.match(/vs\/workbench\/services\/\w+/);
+		const matchPart = currentFile.match(/vs\/workbench\/parts\/\w+/);
+		if (!matchService && !matchPart) {
+			return;
+		}
+
+		const resource = matchService ? matchService[0] : matchPart[0];
+		let resourceDefined = false;
+
+		let json;
+		try {
+			json = fs.readFileSync('./build/lib/i18n.resources.json', 'utf8');
+		} catch (e) {
+			console.error('[translation-remind rule]: File with resources to pull from Transifex was not found. Aborting translation resource check for newly defined workbench part/service.');
+			return;
+		}
+		const workbenchResources = JSON.parse(json).workbench;
+
+		workbenchResources.forEach(existingResource => {
+			if (existingResource.name === resource) {
+				resourceDefined = true;
+				return;
+			}
+		});
+
+		if (!resourceDefined) {
+			this.addFailureAtNode(node, `Please add '${resource}' to ./builds/lib/i18n.resources.json file to use translations here.`);
+		}
+	}
+}