cargdev/angular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(build): add missing return types now enforced by linter

Browse Source
This commit is contained in:
Alex Eagle
2015-06-26 11:10:52 -07:00
parent bc585f2724
commit 44891996b5
61 changed files with 467 additions and 400 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
modules/angular2/src/change_detection/change_detection_jit_generator.ts
View File

@ -138,9 +138,9 @@ export class ChangeDetectorJITGenerator {
.map((d) => this._genGetDetector(d.directiveIndex));
}
_genGetDirective(d: DirectiveIndex) { return `this.directive_${d.name}`; }
_genGetDirective(d: DirectiveIndex): string { return `this.directive_${d.name}`; }
_genGetDetector(d: DirectiveIndex) { return `this.detector_${d.name}`; }
_genGetDetector(d: DirectiveIndex): string { return `this.detector_${d.name}`; }
_getNonNullPipeNames(): List<string> {
var pipes = [];
@ -152,7 +152,7 @@ export class ChangeDetectorJITGenerator {
return pipes;
}
_genFieldDefinitions() {
_genFieldDefinitions(): string {
var fields = [];
fields = fields.concat(this._fieldNames);
fields = fields.concat(this._getNonNullPipeNames());
@ -226,7 +226,7 @@ export class ChangeDetectorJITGenerator {
return `${rec}${this._maybeGenLastInDirective(r)}`;
}
_genDirectiveLifecycle(r: ProtoRecord) {
_genDirectiveLifecycle(r: ProtoRecord): string {
if (r.name === "onCheck") {
return this._genOnCheck(r);
} else if (r.name === "onInit") {

70
modules/angular2/src/change_detection/change_detection_util.ts
View File

@ -35,7 +35,7 @@ var _simpleChanges = [
new SimpleChange(null, null)
];
function _simpleChange(previousValue, currentValue) {
function _simpleChange(previousValue, currentValue): SimpleChange {
var index = _simpleChangesIndex++ % 20;
var s = _simpleChanges[index];
s.previousValue = previousValue;
@ -44,41 +44,43 @@ function _simpleChange(previousValue, currentValue) {
}
export class ChangeDetectionUtil {
static uninitialized() { return uninitialized; }
static uninitialized(): Object { return uninitialized; }
static arrayFn0() { return []; }
static arrayFn1(a1) { return [a1]; }
static arrayFn2(a1, a2) { return [a1, a2]; }
static arrayFn3(a1, a2, a3) { return [a1, a2, a3]; }
static arrayFn4(a1, a2, a3, a4) { return [a1, a2, a3, a4]; }
static arrayFn5(a1, a2, a3, a4, a5) { return [a1, a2, a3, a4, a5]; }
static arrayFn6(a1, a2, a3, a4, a5, a6) { return [a1, a2, a3, a4, a5, a6]; }
static arrayFn7(a1, a2, a3, a4, a5, a6, a7) { return [a1, a2, a3, a4, a5, a6, a7]; }
static arrayFn8(a1, a2, a3, a4, a5, a6, a7, a8) { return [a1, a2, a3, a4, a5, a6, a7, a8]; }
static arrayFn9(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
static arrayFn0(): any[] { return []; }
static arrayFn1(a1): any[] { return [a1]; }
static arrayFn2(a1, a2): any[] { return [a1, a2]; }
static arrayFn3(a1, a2, a3): any[] { return [a1, a2, a3]; }
static arrayFn4(a1, a2, a3, a4): any[] { return [a1, a2, a3, a4]; }
static arrayFn5(a1, a2, a3, a4, a5): any[] { return [a1, a2, a3, a4, a5]; }
static arrayFn6(a1, a2, a3, a4, a5, a6): any[] { return [a1, a2, a3, a4, a5, a6]; }
static arrayFn7(a1, a2, a3, a4, a5, a6, a7): any[] { return [a1, a2, a3, a4, a5, a6, a7]; }
static arrayFn8(a1, a2, a3, a4, a5, a6, a7, a8): any[] {
return [a1, a2, a3, a4, a5, a6, a7, a8];
}
static arrayFn9(a1, a2, a3, a4, a5, a6, a7, a8, a9): any[] {
return [a1, a2, a3, a4, a5, a6, a7, a8, a9];
}
static operation_negate(value) { return !value; }
static operation_add(left, right) { return left + right; }
static operation_subtract(left, right) { return left - right; }
static operation_multiply(left, right) { return left * right; }
static operation_divide(left, right) { return left / right; }
static operation_remainder(left, right) { return left % right; }
static operation_equals(left, right) { return left == right; }
static operation_not_equals(left, right) { return left != right; }
static operation_identical(left, right) { return left === right; }
static operation_not_identical(left, right) { return left !== right; }
static operation_less_then(left, right) { return left < right; }
static operation_greater_then(left, right) { return left > right; }
static operation_less_or_equals_then(left, right) { return left <= right; }
static operation_greater_or_equals_then(left, right) { return left >= right; }
static operation_logical_and(left, right) { return left && right; }
static operation_logical_or(left, right) { return left || right; }
static cond(cond, trueVal, falseVal) { return cond ? trueVal : falseVal; }
static operation_negate(value): any { return !value; }
static operation_add(left, right): any { return left + right; }
static operation_subtract(left, right): any { return left - right; }
static operation_multiply(left, right): any { return left * right; }
static operation_divide(left, right): any { return left / right; }
static operation_remainder(left, right): any { return left % right; }
static operation_equals(left, right): any { return left == right; }
static operation_not_equals(left, right): any { return left != right; }
static operation_identical(left, right): any { return left === right; }
static operation_not_identical(left, right): any { return left !== right; }
static operation_less_then(left, right): any { return left < right; }
static operation_greater_then(left, right): any { return left > right; }
static operation_less_or_equals_then(left, right): any { return left <= right; }
static operation_greater_or_equals_then(left, right): any { return left >= right; }
static operation_logical_and(left, right): any { return left && right; }
static operation_logical_or(left, right): any { return left || right; }
static cond(cond, trueVal, falseVal): any { return cond ? trueVal : falseVal; }
static mapFn(keys: List<any>) {
function buildMap(values) {
static mapFn(keys: List<any>): any {
function buildMap(values): StringMap<any, any> {
var res = StringMapWrapper.create();
for (var i = 0; i < keys.length; ++i) {
StringMapWrapper.set(res, keys[i], values[i]);
@ -113,7 +115,7 @@ export class ChangeDetectionUtil {
}
}
static keyedAccess(obj, args) { return obj[args[0]]; }
static keyedAccess(obj, args): any { return obj[args[0]]; }
static unwrapValue(value: any): any {
if (value instanceof WrappedValue) {
@ -129,7 +131,7 @@ export class ChangeDetectionUtil {
static throwDehydrated() { throw new DehydratedException(); }
static changeDetectionMode(strategy: string) {
static changeDetectionMode(strategy: string): string {
return strategy == ON_PUSH ? CHECK_ONCE : CHECK_ALWAYS;
}
@ -137,7 +139,7 @@ export class ChangeDetectionUtil {
return _simpleChange(previousValue, currentValue);
}
static addChange(changes, propertyName: string, change) {
static addChange(changes, propertyName: string, change): Map<any, any> {
if (isBlank(changes)) {
changes = {};
}

2
modules/angular2/src/change_detection/dynamic_change_detector.ts
View File

@ -318,7 +318,7 @@ export class DynamicChangeDetector extends AbstractChangeDetector {
}
}
function isSame(a, b) {
function isSame(a, b): boolean {
if (a === b) return true;
if (a instanceof String && b instanceof String && a == b) return true;
if ((a !== a) && (b !== b)) return true;

126
modules/angular2/src/change_detection/parser/ast.ts
View File

@ -15,7 +15,7 @@ export class AST {
}
export class EmptyExpr extends AST {
eval(context, locals: Locals) { return null; }
eval(context, locals: Locals): any { return null; }
visit(visitor: AstVisitor) {
// do nothing
@ -23,9 +23,9 @@ export class EmptyExpr extends AST {
}
export class ImplicitReceiver extends AST {
eval(context, locals: Locals) { return context; }
eval(context, locals: Locals): any { return context; }
visit(visitor: AstVisitor) { return visitor.visitImplicitReceiver(this); }
visit(visitor: AstVisitor): any { return visitor.visitImplicitReceiver(this); }
}
/**
@ -34,7 +34,7 @@ export class ImplicitReceiver extends AST {
export class Chain extends AST {
constructor(public expressions: List<any>) { super(); }
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
var result;
for (var i = 0; i < this.expressions.length; i++) {
var last = this.expressions[i].eval(context, locals);
@ -43,13 +43,13 @@ export class Chain extends AST {
return result;
}
visit(visitor: AstVisitor) { return visitor.visitChain(this); }
visit(visitor: AstVisitor): any { return visitor.visitChain(this); }
}
export class Conditional extends AST {
constructor(public condition: AST, public trueExp: AST, public falseExp: AST) { super(); }
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
if (this.condition.eval(context, locals)) {
return this.trueExp.eval(context, locals);
} else {
@ -57,7 +57,7 @@ export class Conditional extends AST {
}
}
visit(visitor: AstVisitor) { return visitor.visitConditional(this); }
visit(visitor: AstVisitor): any { return visitor.visitConditional(this); }
}
export class If extends AST {
@ -71,7 +71,7 @@ export class If extends AST {
}
}
visit(visitor: AstVisitor) { return visitor.visitIf(this); }
visit(visitor: AstVisitor): any { return visitor.visitIf(this); }
}
export class AccessMember extends AST {
@ -80,7 +80,7 @@ export class AccessMember extends AST {
super();
}
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
if (this.receiver instanceof ImplicitReceiver && isPresent(locals) &&
locals.contains(this.name)) {
return locals.get(this.name);
@ -92,7 +92,7 @@ export class AccessMember extends AST {
get isAssignable(): boolean { return true; }
assign(context, locals: Locals, value) {
assign(context, locals: Locals, value): any {
var evaluatedContext = this.receiver.eval(context, locals);
if (this.receiver instanceof ImplicitReceiver && isPresent(locals) &&
@ -103,7 +103,7 @@ export class AccessMember extends AST {
}
}
visit(visitor: AstVisitor) { return visitor.visitAccessMember(this); }
visit(visitor: AstVisitor): any { return visitor.visitAccessMember(this); }
}
export class SafeAccessMember extends AST {
@ -112,18 +112,18 @@ export class SafeAccessMember extends AST {
super();
}
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
var evaluatedReceiver = this.receiver.eval(context, locals);
return isBlank(evaluatedReceiver) ? null : this.getter(evaluatedReceiver);
}
visit(visitor: AstVisitor) { return visitor.visitSafeAccessMember(this); }
visit(visitor: AstVisitor): any { return visitor.visitSafeAccessMember(this); }
}
export class KeyedAccess extends AST {
constructor(public obj: AST, public key: AST) { super(); }
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
var obj: any = this.obj.eval(context, locals);
var key: any = this.key.eval(context, locals);
return obj[key];
@ -131,44 +131,44 @@ export class KeyedAccess extends AST {
get isAssignable(): boolean { return true; }
assign(context, locals: Locals, value) {
assign(context, locals: Locals, value): any {
var obj: any = this.obj.eval(context, locals);
var key: any = this.key.eval(context, locals);
obj[key] = value;
return value;
}
visit(visitor: AstVisitor) { return visitor.visitKeyedAccess(this); }
visit(visitor: AstVisitor): any { return visitor.visitKeyedAccess(this); }
}
export class BindingPipe extends AST {
constructor(public exp: AST, public name: string, public args: List<any>) { super(); }
visit(visitor: AstVisitor) { return visitor.visitPipe(this); }
visit(visitor: AstVisitor): any { return visitor.visitPipe(this); }
}
export class LiteralPrimitive extends AST {
constructor(public value) { super(); }
eval(context, locals: Locals) { return this.value; }
eval(context, locals: Locals): any { return this.value; }
visit(visitor: AstVisitor) { return visitor.visitLiteralPrimitive(this); }
visit(visitor: AstVisitor): any { return visitor.visitLiteralPrimitive(this); }
}
export class LiteralArray extends AST {
constructor(public expressions: List<any>) { super(); }
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
return ListWrapper.map(this.expressions, (e) => e.eval(context, locals));
}
visit(visitor: AstVisitor) { return visitor.visitLiteralArray(this); }
visit(visitor: AstVisitor): any { return visitor.visitLiteralArray(this); }
}
export class LiteralMap extends AST {
constructor(public keys: List<any>, public values: List<any>) { super(); }
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
var res = StringMapWrapper.create();
for (var i = 0; i < this.keys.length; ++i) {
StringMapWrapper.set(res, this.keys[i], this.values[i].eval(context, locals));
@ -176,13 +176,15 @@ export class LiteralMap extends AST {
return res;
}
visit(visitor: AstVisitor) { return visitor.visitLiteralMap(this); }
visit(visitor: AstVisitor): any { return visitor.visitLiteralMap(this); }
}
export class Interpolation extends AST {
constructor(public strings: List<any>, public expressions: List<any>) { super(); }
eval(context, locals) { throw new BaseException("evaluating an Interpolation is not supported"); }
eval(context, locals): any {
throw new BaseException("evaluating an Interpolation is not supported");
}
visit(visitor: AstVisitor) { visitor.visitInterpolation(this); }
}
@ -190,7 +192,7 @@ export class Interpolation extends AST {
export class Binary extends AST {
constructor(public operation: string, public left: AST, public right: AST) { super(); }
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
var left: any = this.left.eval(context, locals);
switch (this.operation) {
case '&&':
@ -235,25 +237,25 @@ export class Binary extends AST {
throw 'Internal error [$operation] not handled';
}
visit(visitor: AstVisitor) { return visitor.visitBinary(this); }
visit(visitor: AstVisitor): any { return visitor.visitBinary(this); }
}
export class PrefixNot extends AST {
constructor(public expression: AST) { super(); }
eval(context, locals: Locals) { return !this.expression.eval(context, locals); }
eval(context, locals: Locals): any { return !this.expression.eval(context, locals); }
visit(visitor: AstVisitor) { return visitor.visitPrefixNot(this); }
visit(visitor: AstVisitor): any { return visitor.visitPrefixNot(this); }
}
export class Assignment extends AST {
constructor(public target: AST, public value: AST) { super(); }
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
return this.target.assign(context, locals, this.value.eval(context, locals));
}
visit(visitor: AstVisitor) { return visitor.visitAssignment(this); }
visit(visitor: AstVisitor): any { return visitor.visitAssignment(this); }
}
export class MethodCall extends AST {
@ -262,7 +264,7 @@ export class MethodCall extends AST {
super();
}
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
var evaluatedArgs = evalList(context, locals, this.args);
if (this.receiver instanceof ImplicitReceiver && isPresent(locals) &&
locals.contains(this.name)) {
@ -274,7 +276,7 @@ export class MethodCall extends AST {
}
}
visit(visitor: AstVisitor) { return visitor.visitMethodCall(this); }
visit(visitor: AstVisitor): any { return visitor.visitMethodCall(this); }
}
export class SafeMethodCall extends AST {
@ -283,20 +285,20 @@ export class SafeMethodCall extends AST {
super();
}
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
var evaluatedReceiver = this.receiver.eval(context, locals);
if (isBlank(evaluatedReceiver)) return null;
var evaluatedArgs = evalList(context, locals, this.args);
return this.fn(evaluatedReceiver, evaluatedArgs);
}
visit(visitor: AstVisitor) { return visitor.visitSafeMethodCall(this); }
visit(visitor: AstVisitor): any { return visitor.visitSafeMethodCall(this); }
}
export class FunctionCall extends AST {
constructor(public target: AST, public args: List<any>) { super(); }
eval(context, locals: Locals) {
eval(context, locals: Locals): any {
var obj: any = this.target.eval(context, locals);
if (!(obj instanceof Function)) {
throw new BaseException(`${obj} is not a function`);
@ -304,19 +306,19 @@ export class FunctionCall extends AST {
return FunctionWrapper.apply(obj, evalList(context, locals, this.args));
}
visit(visitor: AstVisitor) { return visitor.visitFunctionCall(this); }
visit(visitor: AstVisitor): any { return visitor.visitFunctionCall(this); }
}
export class ASTWithSource extends AST {
constructor(public ast: AST, public source: string, public location: string) { super(); }
eval(context, locals: Locals) { return this.ast.eval(context, locals); }
eval(context, locals: Locals): any { return this.ast.eval(context, locals); }
get isAssignable(): boolean { return this.ast.isAssignable; }
assign(context, locals: Locals, value) { return this.ast.assign(context, locals, value); }
assign(context, locals: Locals, value): any { return this.ast.assign(context, locals, value); }
visit(visitor: AstVisitor) { return this.ast.visit(visitor); }
visit(visitor: AstVisitor): any { return this.ast.visit(visitor); }
toString(): string { return `${this.source} in ${this.location}`; }
}
@ -348,58 +350,64 @@ export interface AstVisitor {
}
export class AstTransformer implements AstVisitor {
visitImplicitReceiver(ast: ImplicitReceiver) { return ast; }
visitImplicitReceiver(ast: ImplicitReceiver): ImplicitReceiver { return ast; }
visitInterpolation(ast: Interpolation) {
visitInterpolation(ast: Interpolation): Interpolation {
return new Interpolation(ast.strings, this.visitAll(ast.expressions));
}
visitLiteralPrimitive(ast: LiteralPrimitive) { return new LiteralPrimitive(ast.value); }
visitLiteralPrimitive(ast: LiteralPrimitive): LiteralPrimitive {
return new LiteralPrimitive(ast.value);
}
visitAccessMember(ast: AccessMember) {
visitAccessMember(ast: AccessMember): AccessMember {
return new AccessMember(ast.receiver.visit(this), ast.name, ast.getter, ast.setter);
}
visitSafeAccessMember(ast: SafeAccessMember) {
visitSafeAccessMember(ast: SafeAccessMember): SafeAccessMember {
return new SafeAccessMember(ast.receiver.visit(this), ast.name, ast.getter, ast.setter);
}
visitMethodCall(ast: MethodCall) {
visitMethodCall(ast: MethodCall): MethodCall {
return new MethodCall(ast.receiver.visit(this), ast.name, ast.fn, this.visitAll(ast.args));
}
visitSafeMethodCall(ast: SafeMethodCall) {
visitSafeMethodCall(ast: SafeMethodCall): SafeMethodCall {
return new SafeMethodCall(ast.receiver.visit(this), ast.name, ast.fn, this.visitAll(ast.args));
}
visitFunctionCall(ast: FunctionCall) {
visitFunctionCall(ast: FunctionCall): FunctionCall {
return new FunctionCall(ast.target.visit(this), this.visitAll(ast.args));
}
visitLiteralArray(ast: LiteralArray) { return new LiteralArray(this.visitAll(ast.expressions)); }
visitLiteralArray(ast: LiteralArray): LiteralArray {
return new LiteralArray(this.visitAll(ast.expressions));
}
visitLiteralMap(ast: LiteralMap) { return new LiteralMap(ast.keys, this.visitAll(ast.values)); }
visitLiteralMap(ast: LiteralMap): LiteralMap {
return new LiteralMap(ast.keys, this.visitAll(ast.values));
}
visitBinary(ast: Binary) {
visitBinary(ast: Binary): Binary {
return new Binary(ast.operation, ast.left.visit(this), ast.right.visit(this));
}
visitPrefixNot(ast: PrefixNot) { return new PrefixNot(ast.expression.visit(this)); }
visitPrefixNot(ast: PrefixNot): PrefixNot { return new PrefixNot(ast.expression.visit(this)); }
visitConditional(ast: Conditional) {
visitConditional(ast: Conditional): Conditional {
return new Conditional(ast.condition.visit(this), ast.trueExp.visit(this),
ast.falseExp.visit(this));
}
visitPipe(ast: BindingPipe) {
visitPipe(ast: BindingPipe): BindingPipe {
return new BindingPipe(ast.exp.visit(this), ast.name, this.visitAll(ast.args));
}
visitKeyedAccess(ast: KeyedAccess) {
visitKeyedAccess(ast: KeyedAccess): KeyedAccess {
return new KeyedAccess(ast.obj.visit(this), ast.key.visit(this));
}
visitAll(asts: List<any>) {
visitAll(asts: List<any>): List<any> {
var res = ListWrapper.createFixedSize(asts.length);
for (var i = 0; i < asts.length; ++i) {
res[i] = asts[i].visit(this);
@ -407,13 +415,13 @@ export class AstTransformer implements AstVisitor {
return res;
}
visitChain(ast: Chain) { return new Chain(this.visitAll(ast.expressions)); }
visitChain(ast: Chain): Chain { return new Chain(this.visitAll(ast.expressions)); }
visitAssignment(ast: Assignment) {
visitAssignment(ast: Assignment): Assignment {
return new Assignment(ast.target.visit(this), ast.value.visit(this));
}
visitIf(ast: If) {
visitIf(ast: If): If {
let falseExp = isPresent(ast.falseExp) ? ast.falseExp.visit(this) : null;
return new If(ast.condition.visit(this), ast.trueExp.visit(this), falseExp);
}
@ -433,7 +441,7 @@ var _evalListCache = [
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
];
function evalList(context, locals: Locals, exps: List<any>) {
function evalList(context, locals: Locals, exps: List<any>): any[] {
var length = exps.length;
if (length > 10) {
throw new BaseException("Cannot have more than 10 argument");

4
modules/angular2/src/change_detection/parser/locals.ts
View File

@ -16,7 +16,7 @@ export class Locals {
return false;
}
get(name: string) {
get(name: string): any {
if (this.current.has(name)) {
return this.current.get(name);
}
@ -41,4 +41,4 @@ export class Locals {
}
clearValues(): void { MapWrapper.clearValues(this.current); }
}
}

41
modules/angular2/src/change_detection/parser/parser.ts
View File

@ -217,7 +217,7 @@ class _ParseAST {
return ast;
}
parsePipe() {
parsePipe(): AST {
var result = this.parseExpression();
if (this.optionalOperator("|")) {
if (this.parseAction) {
@ -237,7 +237,7 @@ class _ParseAST {
return result;
}
parseExpression() {
parseExpression(): AST {
var start = this.inputIndex;
var result = this.parseConditional();
@ -259,7 +259,7 @@ class _ParseAST {
return result;
}
parseConditional() {
parseConditional(): AST {
var start = this.inputIndex;
var result = this.parseLogicalOr();
@ -277,7 +277,7 @@ class _ParseAST {
}
}
parseLogicalOr() {
parseLogicalOr(): AST {
// '||'
var result = this.parseLogicalAnd();
while (this.optionalOperator('||')) {
@ -286,7 +286,7 @@ class _ParseAST {
return result;
}
parseLogicalAnd() {
parseLogicalAnd(): AST {
// '&&'
var result = this.parseEquality();
while (this.optionalOperator('&&')) {
@ -295,7 +295,7 @@ class _ParseAST {
return result;
}
parseEquality() {
parseEquality(): AST {
// '==','!=','===','!=='
var result = this.parseRelational();
while (true) {
@ -313,7 +313,7 @@ class _ParseAST {
}
}
parseRelational() {
parseRelational(): AST {
// '<', '>', '<=', '>='
var result = this.parseAdditive();
while (true) {
@ -331,7 +331,7 @@ class _ParseAST {
}
}
parseAdditive() {
parseAdditive(): AST {
// '+', '-'
var result = this.parseMultiplicative();
while (true) {
@ -345,7 +345,7 @@ class _ParseAST {
}
}
parseMultiplicative() {
parseMultiplicative(): AST {
// '*', '%', '/'
var result = this.parsePrefix();
while (true) {
@ -361,7 +361,7 @@ class _ParseAST {
}
}
parsePrefix() {
parsePrefix(): AST {
if (this.optionalOperator('+')) {
return this.parsePrefix();
} else if (this.optionalOperator('-')) {
@ -398,12 +398,11 @@ class _ParseAST {
}
}
parsePrimary() {
parsePrimary(): AST {
if (this.optionalCharacter($LPAREN)) {
let result = this.parsePipe();
this.expectCharacter($RPAREN);
return result
return result;
} else if (this.next.isKeywordNull() || this.next.isKeywordUndefined()) {
this.advance();
return new LiteralPrimitive(null);
@ -427,7 +426,7 @@ class _ParseAST {
this.advance();
elseExp = this.parseExpressionOrBlock();
}
return new If(condition, ifExp, elseExp)
return new If(condition, ifExp, elseExp);
} else if (this.optionalCharacter($LBRACKET)) {
var elements = this.parseExpressionList($RBRACKET);
@ -456,6 +455,8 @@ class _ParseAST {
} else {
this.error(`Unexpected token ${this.next}`);
}
// error() throws, so we don't reach here.
throw new BaseException("Fell through all cases in parsePrimary");
}
parseExpressionList(terminator: int): List<any> {
@ -468,7 +469,7 @@ class _ParseAST {
return result;
}
parseLiteralMap() {
parseLiteralMap(): LiteralMap {
var keys = [];
var values = [];
this.expectCharacter($LBRACE);
@ -502,7 +503,7 @@ class _ParseAST {
}
}
parseCallArguments() {
parseCallArguments(): BindingPipe[] {
if (this.next.isCharacter($RPAREN)) return [];
var positionals = [];
do {
@ -545,7 +546,7 @@ class _ParseAST {
/**
* An identifier, a keyword, a string with an optional `-` inbetween.
*/
expectTemplateBindingKey() {
expectTemplateBindingKey(): string {
var result = '';
var operatorFound = false;
do {
@ -559,7 +560,7 @@ class _ParseAST {
return result.toString();
}
parseTemplateBindings() {
parseTemplateBindings(): any[] {
var bindings = [];
var prefix = null;
while (this.index < this.tokens.length) {
@ -607,7 +608,7 @@ class _ParseAST {
}
class SimpleExpressionChecker implements AstVisitor {
static check(ast: AST) {
static check(ast: AST): boolean {
var s = new SimpleExpressionChecker();
ast.visit(s);
return s.simple;
@ -645,7 +646,7 @@ class SimpleExpressionChecker implements AstVisitor {
visitKeyedAccess(ast: KeyedAccess) { this.simple = false; }
visitAll(asts: List<any>) {
visitAll(asts: List<any>): List<any> {
var res = ListWrapper.createFixedSize(asts.length);
for (var i = 0; i < asts.length; ++i) {
res[i] = asts[i].visit(this);

4
modules/angular2/src/change_detection/pipes/null_pipe.ts
View File

@ -19,9 +19,9 @@ export class NullPipe extends BasePipe {
static supportsObj(obj): boolean { return isBlank(obj); }
supports(obj) { return NullPipe.supportsObj(obj); }
supports(obj): boolean { return NullPipe.supportsObj(obj); }
transform(value) {
transform(value): WrappedValue {
if (!this.called) {
this.called = true;
return WrappedValue.wrap(null);

34
modules/angular2/src/change_detection/proto_change_detector.ts
View File

@ -43,7 +43,7 @@ export class DynamicProtoChangeDetector implements ProtoChangeDetector {
this._records = this._createRecords(definition);
}
instantiate(dispatcher: any) {
instantiate(dispatcher: any): ChangeDetector {
return new DynamicChangeDetector(this.definition.id, this.definition.strategy, dispatcher,
this._pipeRegistry, this._records,
this.definition.directiveRecords);
@ -95,19 +95,19 @@ class _ConvertAstIntoProtoRecords implements AstVisitor {
b.ast.visit(c);
}
visitImplicitReceiver(ast: ImplicitReceiver) { return this._bindingRecord.implicitReceiver; }
visitImplicitReceiver(ast: ImplicitReceiver): any { return this._bindingRecord.implicitReceiver; }
visitInterpolation(ast: Interpolation) {
visitInterpolation(ast: Interpolation): number {
var args = this._visitAll(ast.expressions);
return this._addRecord(RecordType.INTERPOLATE, "interpolate", _interpolationFn(ast.strings),
args, ast.strings, 0);
}
visitLiteralPrimitive(ast: LiteralPrimitive) {
visitLiteralPrimitive(ast: LiteralPrimitive): number {
return this._addRecord(RecordType.CONST, "literal", ast.value, [], null, 0);
}
visitAccessMember(ast: AccessMember) {
visitAccessMember(ast: AccessMember): number {
var receiver = ast.receiver.visit(this);
if (isPresent(this._variableNames) && ListWrapper.contains(this._variableNames, ast.name) &&
ast.receiver instanceof
@ -118,12 +118,12 @@ class _ConvertAstIntoProtoRecords implements AstVisitor {
}
}
visitSafeAccessMember(ast: SafeAccessMember) {
visitSafeAccessMember(ast: SafeAccessMember): number {
var receiver = ast.receiver.visit(this);
return this._addRecord(RecordType.SAFE_PROPERTY, ast.name, ast.getter, [], null, receiver);
}
visitMethodCall(ast: MethodCall) {
visitMethodCall(ast: MethodCall): number {
var receiver = ast.receiver.visit(this);
var args = this._visitAll(ast.args);
if (isPresent(this._variableNames) && ListWrapper.contains(this._variableNames, ast.name)) {
@ -134,44 +134,44 @@ class _ConvertAstIntoProtoRecords implements AstVisitor {
}
}
visitSafeMethodCall(ast: SafeMethodCall) {
visitSafeMethodCall(ast: SafeMethodCall): number {
var receiver = ast.receiver.visit(this);
var args = this._visitAll(ast.args);
return this._addRecord(RecordType.SAFE_INVOKE_METHOD, ast.name, ast.fn, args, null, receiver);
}
visitFunctionCall(ast: FunctionCall) {
visitFunctionCall(ast: FunctionCall): number {
var target = ast.target.visit(this);
var args = this._visitAll(ast.args);
return this._addRecord(RecordType.INVOKE_CLOSURE, "closure", null, args, null, target);
}
visitLiteralArray(ast: LiteralArray) {
visitLiteralArray(ast: LiteralArray): number {
var primitiveName = `arrayFn${ast.expressions.length}`;
return this._addRecord(RecordType.PRIMITIVE_OP, primitiveName, _arrayFn(ast.expressions.length),
this._visitAll(ast.expressions), null, 0);
}
visitLiteralMap(ast: LiteralMap) {
visitLiteralMap(ast: LiteralMap): number {
return this._addRecord(RecordType.PRIMITIVE_OP, _mapPrimitiveName(ast.keys),
ChangeDetectionUtil.mapFn(ast.keys), this._visitAll(ast.values), null,
0);
}
visitBinary(ast: Binary) {
visitBinary(ast: Binary): number {
var left = ast.left.visit(this);
var right = ast.right.visit(this);
return this._addRecord(RecordType.PRIMITIVE_OP, _operationToPrimitiveName(ast.operation),
_operationToFunction(ast.operation), [left, right], null, 0);
}
visitPrefixNot(ast: PrefixNot) {
visitPrefixNot(ast: PrefixNot): number {
var exp = ast.expression.visit(this);
return this._addRecord(RecordType.PRIMITIVE_OP, "operation_negate",
ChangeDetectionUtil.operation_negate, [exp], null, 0);
}
visitConditional(ast: Conditional) {
visitConditional(ast: Conditional): number {
var c = ast.condition.visit(this);
var t = ast.trueExp.visit(this);
var f = ast.falseExp.visit(this);
@ -179,12 +179,12 @@ class _ConvertAstIntoProtoRecords implements AstVisitor {
null, 0);
}
visitPipe(ast: BindingPipe) {
visitPipe(ast: BindingPipe): number {
var value = ast.exp.visit(this);
return this._addRecord(RecordType.PIPE, ast.name, ast.name, [], null, value);
}
visitKeyedAccess(ast: KeyedAccess) {
visitKeyedAccess(ast: KeyedAccess): number {
var obj = ast.obj.visit(this);
var key = ast.key.visit(this);
return this._addRecord(RecordType.KEYED_ACCESS, "keyedAccess", ChangeDetectionUtil.keyedAccess,
@ -328,7 +328,7 @@ function _operationToFunction(operation: string): Function {
}
}
function s(v) {
function s(v): string {
return isPresent(v) ? `${v}` : '';
}