Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
import * as ts from "typescript";
import * as Lint from "tslint/lib/lint";
export class Rule extends Lint.Rules.AbstractRule {
public static FAILURE_STRING = "No implicit return value type is forbidden";
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
return this.applyWithWalker(new NoImplicitReturnTypeWalker(sourceFile, this.getOptions()));
}
}
// The walker takes care of all the work.
class NoImplicitReturnTypeWalker extends Lint.RuleWalker {
public visitMethodDeclaration(node: ts.MethodDeclaration) {
if (!node.type) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING + " at: " + node.name.text));
}
//if(node.type)console.log(this.sourceFile.text.substring(node.type.pos,node.type.end));
// call the base version of this visitor to actually parse this node
super.visitMethodDeclaration(node);
}
public visitPropertyDeclaration(node: ts.PropertyDeclaration) {
if (!node.type) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING + " at: " + node.name.text));
}
// call the base version of this visitor to actually parse this node
super.visitPropertyDeclaration(node);
}
var modifiers = this.sourceFile.text.substring(node.pos, node.modifiers.end);
if (!/\/\*\*/m.test(modifiers)) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING + " at: " + node.name.text));
}
}
// call the base version of this visitor to actually parse this node
_super.prototype.visitMethodDeclaration.call(this, node);
};
NoPublicMemberWithoutCommentWalker.prototype._isPublic = function (node) {
return Lint.hasModifier(node.modifiers, ts.SyntaxKind.PublicKeyword);
};
NoPublicMemberWithoutCommentWalker.prototype._isProtected = function (node) {
return Lint.hasModifier(node.modifiers, ts.SyntaxKind.ProtectedKeyword);
};
return NoPublicMemberWithoutCommentWalker;
})(Lint.RuleWalker);
NoImplicitReturnTypeWalker.prototype.visitPropertyDeclaration = function (node) {
if (!node.type) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING + " at: " + node.name.text));
}
// call the base version of this visitor to actually parse this node
_super.prototype.visitPropertyDeclaration.call(this, node);
};
NoImplicitReturnTypeWalker.prototype.visitAccessorDeclaration = function (node) {
if (!node.type) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING + " at: " + node.name.text));
}
// call the base version of this visitor to actually parse this node
_super.prototype.visitAccessorDeclaration.call(this, node);
};
return NoImplicitReturnTypeWalker;
})(Lint.RuleWalker);
import * as ts from 'typescript';
import * as Lint from 'tslint/lib/lint';
/**
* A base walker class that gracefully handles unexpected errors.
* Errors are often thrown when the TypeChecker is invoked.
*/
export class ErrorTolerantWalker extends Lint.RuleWalker {
private static DEBUG: boolean = true;
protected visitNode(node: ts.Node): void {
try {
super.visitNode(node);
} catch (e) {
// turn this on when trying out new rules on foreign codebases
if (ErrorTolerantWalker.DEBUG) {
const msg: string = 'An error occurred visiting a node.'
+ '\nWalker: ' + this.getClassName()
+ '\nNode: ' + (node.getFullText ? node.getFullText() : '')
+ '\n' + e;
this.addFailure(this.createFailure(
node.getStart ? node.getStart() : 0,
import * as ts from 'typescript'
import * as Lint from 'tslint/lib/lint'
export class Rule extends Lint.Rules.AbstractRule {
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
if (sourceFile.languageVariant === ts.LanguageVariant.JSX) {
return this.applyWithWalker(new ReactReadonlyPropsAndStateWalker(sourceFile, this.getOptions()))
} else {
return []
}
}
}
// The walker takes care of all the work.
class ReactReadonlyPropsAndStateWalker extends Lint.RuleWalker {
protected visitInterfaceDeclaration(node: ts.InterfaceDeclaration): void {
if (node.name.text.endsWith('Props')) {
this.ensureReadOnly(node.members)
}
if (node.name.text.endsWith('State')) {
this.ensureReadOnly(node.members)
}
super.visitInterfaceDeclaration(node)
}
private ensureReadOnly(members: ts.NodeArray) {
members.forEach(member => {
if (member.kind !== ts.SyntaxKind.PropertySignature) { return }
import * as Lint from 'tslint/lib/lint';
import * as ts from 'typescript';
import {sprintf} from 'sprintf-js';
import {RuleBase} from "./util/rulesBase";
export class ClassMetadataWalker extends Lint.RuleWalker {
private languageService:ts.LanguageService;
private typeChecker:ts.TypeChecker;
constructor(sourceFile:ts.SourceFile, languageService:ts.LanguageService, private rule:RuleBase) {
super(sourceFile, rule.getOptions());
this.languageService = languageService;
this.typeChecker = languageService.getProgram().getTypeChecker();
}
visitClassDeclaration(node:ts.ClassDeclaration) {
(node.members || []).forEach(this.validateClassMember.bind(this, node.name.text));
super.visitClassDeclaration(node);
}
validateClassMember(className:string, member) {
import * as Lint from 'tslint/lib/lint';
import * as ts from 'typescript';
import {sprintf} from 'sprintf-js';
import {RuleBase} from "./util/rulesBase";
export class ExpressionCallMetadataWalker extends Lint.RuleWalker {
private languageService:ts.LanguageService;
private typeChecker:ts.TypeChecker;
constructor(sourceFile:ts.SourceFile, languageService:ts.LanguageService, private rule:RuleBase) {
super(sourceFile, rule.getOptions());
this.languageService = languageService;
this.typeChecker = languageService.getProgram().getTypeChecker();
}
visitCallExpression(node:ts.CallExpression) {
this.validateCallExpression(node);
super.visitCallExpression(node);
}
private validateCallExpression(callExpression) {
if (this.rule.validate(callExpression)) {
var fileImports = this.getFileImports(sourceFile.fileName);
var importPath = node.moduleSpecifier.text;
if (fileImports[importPath] != null) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING));
}
else {
fileImports[importPath] = true;
}
_super.prototype.visitImportDeclaration.call(this, node);
};
NoDuplicateImportsFromSameFileWalker.prototype.getFileImports = function (fileName) {
this.fileImportsByFileName[fileName] = this.fileImportsByFileName[fileName] || {};
return this.fileImportsByFileName[fileName];
};
return NoDuplicateImportsFromSameFileWalker;
}(Lint.RuleWalker));
var fileImports = this.getFileImports(sourceFile.fileName);
var importPath = node.moduleSpecifier.text;
if (fileImports[importPath] != null) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING));
}
else {
fileImports[importPath] = true;
}
_super.prototype.visitImportDeclaration.call(this, node);
};
NoDuplicateImportsFromSameFileWalker.prototype.getFileImports = function (fileName) {
this.fileImportsByFileName[fileName] = this.fileImportsByFileName[fileName] || {};
return this.fileImportsByFileName[fileName];
};
return NoDuplicateImportsFromSameFileWalker;
}(Lint.RuleWalker));
var NoMutationWalker = (function (_super) {
__extends(NoMutationWalker, _super);
function NoMutationWalker() {
_super.apply(this, arguments);
}
NoMutationWalker.prototype.visitNode = function (node) {
if (node && node.kind === ts.SyntaxKind.BinaryExpression
&& node.getChildCount() >= 3
&& node.getChildAt(0).kind === ts.SyntaxKind.PropertyAccessExpression
&& node.getChildAt(1).kind === ts.SyntaxKind.FirstAssignment) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING));
}
_super.prototype.visitNode.call(this, node);
};
return NoMutationWalker;
}(Lint.RuleWalker));