var TypeScript; (function (TypeScript) { function hasFlag(val, flag) { return (val & flag) != 0; } TypeScript.hasFlag = hasFlag; (function (ErrorRecoverySet) { ErrorRecoverySet._map = []; ErrorRecoverySet.None = 0; ErrorRecoverySet.Comma = 1; ErrorRecoverySet.SColon = 1 << 1; ErrorRecoverySet.Asg = 1 << 2; ErrorRecoverySet.BinOp = 1 << 3; ErrorRecoverySet.RBrack = 1 << 4; ErrorRecoverySet.RCurly = 1 << 5; ErrorRecoverySet.RParen = 1 << 6; ErrorRecoverySet.Dot = 1 << 7; ErrorRecoverySet.Colon = 1 << 8; ErrorRecoverySet.PrimType = 1 << 9; ErrorRecoverySet.AddOp = 1 << 10; ErrorRecoverySet.LCurly = 1 << 11; ErrorRecoverySet.PreOp = 1 << 12; ErrorRecoverySet.RegExp = 1 << 13; ErrorRecoverySet.LParen = 1 << 14; ErrorRecoverySet.LBrack = 1 << 15; ErrorRecoverySet.Scope = 1 << 16; ErrorRecoverySet.In = 1 << 17; ErrorRecoverySet.SCase = 1 << 18; ErrorRecoverySet.Else = 1 << 19; ErrorRecoverySet.Catch = 1 << 20; ErrorRecoverySet.Var = 1 << 21; ErrorRecoverySet.Stmt = 1 << 22; ErrorRecoverySet.While = 1 << 23; ErrorRecoverySet.ID = 1 << 24; ErrorRecoverySet.Prefix = 1 << 25; ErrorRecoverySet.Literal = 1 << 26; ErrorRecoverySet.RLit = 1 << 27; ErrorRecoverySet.Func = 1 << 28; ErrorRecoverySet.EOF = 1 << 29; ErrorRecoverySet.TypeScriptS = 1 << 30; ErrorRecoverySet.ExprStart = ErrorRecoverySet.SColon | ErrorRecoverySet.AddOp | ErrorRecoverySet.LCurly | ErrorRecoverySet.PreOp | ErrorRecoverySet.RegExp | ErrorRecoverySet.LParen | ErrorRecoverySet.LBrack | ErrorRecoverySet.ID | ErrorRecoverySet.Prefix | ErrorRecoverySet.RLit | ErrorRecoverySet.Func | ErrorRecoverySet.Literal; ErrorRecoverySet.StmtStart = ErrorRecoverySet.ExprStart | ErrorRecoverySet.SColon | ErrorRecoverySet.Var | ErrorRecoverySet.Stmt | ErrorRecoverySet.While | ErrorRecoverySet.TypeScriptS; ErrorRecoverySet.Postfix = ErrorRecoverySet.Dot | ErrorRecoverySet.LParen | ErrorRecoverySet.LBrack; })(TypeScript.ErrorRecoverySet || (TypeScript.ErrorRecoverySet = {})); var ErrorRecoverySet = TypeScript.ErrorRecoverySet; (function (AllowedElements) { AllowedElements._map = []; AllowedElements.None = 0; AllowedElements.ModuleDeclarations = 1 << 2; AllowedElements.ClassDeclarations = 1 << 3; AllowedElements.InterfaceDeclarations = 1 << 4; AllowedElements.AmbientDeclarations = 1 << 10; AllowedElements.Properties = 1 << 11; AllowedElements.Global = AllowedElements.ModuleDeclarations | AllowedElements.ClassDeclarations | AllowedElements.InterfaceDeclarations | AllowedElements.AmbientDeclarations; AllowedElements.QuickParse = AllowedElements.Global | AllowedElements.Properties; })(TypeScript.AllowedElements || (TypeScript.AllowedElements = {})); var AllowedElements = TypeScript.AllowedElements; (function (Modifiers) { Modifiers._map = []; Modifiers.None = 0; Modifiers.Private = 1; Modifiers.Public = 1 << 1; Modifiers.Readonly = 1 << 2; Modifiers.Ambient = 1 << 3; Modifiers.Exported = 1 << 4; Modifiers.Getter = 1 << 5; Modifiers.Setter = 1 << 6; Modifiers.Static = 1 << 7; })(TypeScript.Modifiers || (TypeScript.Modifiers = {})); var Modifiers = TypeScript.Modifiers; (function (ASTFlags) { ASTFlags._map = []; ASTFlags.None = 0; ASTFlags.ExplicitSemicolon = 1; ASTFlags.AutomaticSemicolon = 1 << 1; ASTFlags.Writeable = 1 << 2; ASTFlags.Error = 1 << 3; ASTFlags.DotLHSPartial = 1 << 4; ASTFlags.DotLHS = 1 << 5; ASTFlags.IsStatement = 1 << 6; ASTFlags.StrictMode = 1 << 7; ASTFlags.PossibleOptionalParameter = 1 << 8; ASTFlags.ClassBaseConstructorCall = 1 << 9; ASTFlags.OptionalName = 1 << 10; ASTFlags.SkipNextRParen = 1 << 11; })(TypeScript.ASTFlags || (TypeScript.ASTFlags = {})); var ASTFlags = TypeScript.ASTFlags; (function (DeclFlags) { DeclFlags._map = []; DeclFlags.None = 0; DeclFlags.Exported = 1; DeclFlags.Private = 1 << 1; DeclFlags.Public = 1 << 2; DeclFlags.Ambient = 1 << 3; DeclFlags.Static = 1 << 4; DeclFlags.LocalStatic = 1 << 5; DeclFlags.GetAccessor = 1 << 6; DeclFlags.SetAccessor = 1 << 7; })(TypeScript.DeclFlags || (TypeScript.DeclFlags = {})); var DeclFlags = TypeScript.DeclFlags; (function (ModuleFlags) { ModuleFlags._map = []; ModuleFlags.None = 0; ModuleFlags.Exported = 1; ModuleFlags.Private = 1 << 1; ModuleFlags.Public = 1 << 2; ModuleFlags.Ambient = 1 << 3; ModuleFlags.Static = 1 << 4; ModuleFlags.LocalStatic = 1 << 5; ModuleFlags.GetAccessor = 1 << 6; ModuleFlags.SetAccessor = 1 << 7; ModuleFlags.IsEnum = 1 << 8; ModuleFlags.ShouldEmitModuleDecl = 1 << 9; ModuleFlags.IsWholeFile = 1 << 10; ModuleFlags.IsDynamic = 1 << 11; ModuleFlags.MustCaptureThis = 1 << 12; })(TypeScript.ModuleFlags || (TypeScript.ModuleFlags = {})); var ModuleFlags = TypeScript.ModuleFlags; (function (SymbolFlags) { SymbolFlags._map = []; SymbolFlags.None = 0; SymbolFlags.Exported = 1; SymbolFlags.Private = 1 << 1; SymbolFlags.Public = 1 << 2; SymbolFlags.Ambient = 1 << 3; SymbolFlags.Static = 1 << 4; SymbolFlags.LocalStatic = 1 << 5; SymbolFlags.GetAccessor = 1 << 6; SymbolFlags.SetAccessor = 1 << 7; SymbolFlags.Property = 1 << 8; SymbolFlags.Readonly = 1 << 9; SymbolFlags.ModuleMember = 1 << 10; SymbolFlags.InterfaceMember = 1 << 11; SymbolFlags.ClassMember = 1 << 12; SymbolFlags.BuiltIn = 1 << 13; SymbolFlags.TypeSetDuringScopeAssignment = 1 << 14; SymbolFlags.Constant = 1 << 15; SymbolFlags.Optional = 1 << 16; SymbolFlags.RecursivelyReferenced = 1 << 17; SymbolFlags.Bound = 1 << 18; SymbolFlags.CompilerGenerated = 1 << 19; })(TypeScript.SymbolFlags || (TypeScript.SymbolFlags = {})); var SymbolFlags = TypeScript.SymbolFlags; (function (VarFlags) { VarFlags._map = []; VarFlags.None = 0; VarFlags.Exported = 1; VarFlags.Private = 1 << 1; VarFlags.Public = 1 << 2; VarFlags.Ambient = 1 << 3; VarFlags.Static = 1 << 4; VarFlags.LocalStatic = 1 << 5; VarFlags.GetAccessor = 1 << 6; VarFlags.SetAccessor = 1 << 7; VarFlags.AutoInit = 1 << 8; VarFlags.Property = 1 << 9; VarFlags.Readonly = 1 << 10; VarFlags.Class = 1 << 11; VarFlags.ClassProperty = 1 << 12; VarFlags.ClassBodyProperty = 1 << 13; VarFlags.ClassConstructorProperty = 1 << 14; VarFlags.ClassSuperMustBeFirstCallInConstructor = 1 << 15; VarFlags.Constant = 1 << 16; VarFlags.MustCaptureThis = 1 << 17; })(TypeScript.VarFlags || (TypeScript.VarFlags = {})); var VarFlags = TypeScript.VarFlags; (function (FncFlags) { FncFlags._map = []; FncFlags.None = 0; FncFlags.Exported = 1; FncFlags.Private = 1 << 1; FncFlags.Public = 1 << 2; FncFlags.Ambient = 1 << 3; FncFlags.Static = 1 << 4; FncFlags.LocalStatic = 1 << 5; FncFlags.GetAccessor = 1 << 6; FncFlags.SetAccessor = 1 << 7; FncFlags.Definition = 1 << 8; FncFlags.Signature = 1 << 9; FncFlags.Method = 1 << 10; FncFlags.HasReturnExpression = 1 << 11; FncFlags.CallMember = 1 << 12; FncFlags.ConstructMember = 1 << 13; FncFlags.HasSelfReference = 1 << 14; FncFlags.IsFatArrowFunction = 1 << 15; FncFlags.IndexerMember = 1 << 16; FncFlags.IsFunctionExpression = 1 << 17; FncFlags.ClassMethod = 1 << 18; FncFlags.ClassPropertyMethodExported = 1 << 19; FncFlags.HasSuperReferenceInFatArrowFunction = 1 << 20; FncFlags.IsPropertyBound = 1 << 21; })(TypeScript.FncFlags || (TypeScript.FncFlags = {})); var FncFlags = TypeScript.FncFlags; (function (SignatureFlags) { SignatureFlags._map = []; SignatureFlags.None = 0; SignatureFlags.IsIndexer = 1; SignatureFlags.IsStringIndexer = 1 << 1; SignatureFlags.IsNumberIndexer = 1 << 2; })(TypeScript.SignatureFlags || (TypeScript.SignatureFlags = {})); var SignatureFlags = TypeScript.SignatureFlags; function ToDeclFlags(fncOrVarOrSymbolOrModuleFlags) { return fncOrVarOrSymbolOrModuleFlags; } TypeScript.ToDeclFlags = ToDeclFlags; (function (TypeFlags) { TypeFlags._map = []; TypeFlags.None = 0; TypeFlags.HasImplementation = 1; TypeFlags.HasSelfReference = 1 << 1; TypeFlags.MergeResult = 1 << 2; TypeFlags.IsEnum = 1 << 3; TypeFlags.BuildingName = 1 << 4; TypeFlags.HasBaseType = 1 << 5; TypeFlags.HasBaseTypeOfObject = 1 << 6; TypeFlags.IsClass = 1 << 7; })(TypeScript.TypeFlags || (TypeScript.TypeFlags = {})); var TypeFlags = TypeScript.TypeFlags; (function (TypeRelationshipFlags) { TypeRelationshipFlags._map = []; TypeRelationshipFlags.SuccessfulComparison = 0; TypeRelationshipFlags.SourceIsNullTargetIsVoidOrUndefined = 1; TypeRelationshipFlags.RequiredPropertyIsMissing = 1 << 1; TypeRelationshipFlags.IncompatibleSignatures = 1 << 2; TypeRelationshipFlags.SourceSignatureHasTooManyParameters = 3; TypeRelationshipFlags.IncompatibleReturnTypes = 1 << 4; TypeRelationshipFlags.IncompatiblePropertyTypes = 1 << 5; TypeRelationshipFlags.IncompatibleParameterTypes = 1 << 6; })(TypeScript.TypeRelationshipFlags || (TypeScript.TypeRelationshipFlags = {})); var TypeRelationshipFlags = TypeScript.TypeRelationshipFlags; (function (CodeGenTarget) { CodeGenTarget._map = []; CodeGenTarget.ES3 = 0; CodeGenTarget.ES5 = 1; })(TypeScript.CodeGenTarget || (TypeScript.CodeGenTarget = {})); var CodeGenTarget = TypeScript.CodeGenTarget; (function (ModuleGenTarget) { ModuleGenTarget._map = []; ModuleGenTarget.Synchronous = 0; ModuleGenTarget.Asynchronous = 1; ModuleGenTarget.Local = 1 << 1; })(TypeScript.ModuleGenTarget || (TypeScript.ModuleGenTarget = {})); var ModuleGenTarget = TypeScript.ModuleGenTarget; TypeScript.codeGenTarget = CodeGenTarget.ES3; TypeScript.moduleGenTarget = ModuleGenTarget.Synchronous; TypeScript.optimizeModuleCodeGen = true; function flagsToString(e, flags) { var builder = ""; for(var i = 1; i < (1 << 31); i = i << 1) { if((flags & i) != 0) { for(var k in e) { if(e[k] == i) { if(builder.length > 0) { builder += "|"; } builder += k; break; } } } } return builder; } TypeScript.flagsToString = flagsToString; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { (function (NodeType) { NodeType._map = []; NodeType._map[0] = "None"; NodeType.None = 0; NodeType._map[1] = "Empty"; NodeType.Empty = 1; NodeType._map[2] = "EmptyExpr"; NodeType.EmptyExpr = 2; NodeType._map[3] = "True"; NodeType.True = 3; NodeType._map[4] = "False"; NodeType.False = 4; NodeType._map[5] = "This"; NodeType.This = 5; NodeType._map[6] = "Super"; NodeType.Super = 6; NodeType._map[7] = "QString"; NodeType.QString = 7; NodeType._map[8] = "Regex"; NodeType.Regex = 8; NodeType._map[9] = "Null"; NodeType.Null = 9; NodeType._map[10] = "ArrayLit"; NodeType.ArrayLit = 10; NodeType._map[11] = "ObjectLit"; NodeType.ObjectLit = 11; NodeType._map[12] = "Void"; NodeType.Void = 12; NodeType._map[13] = "Comma"; NodeType.Comma = 13; NodeType._map[14] = "Pos"; NodeType.Pos = 14; NodeType._map[15] = "Neg"; NodeType.Neg = 15; NodeType._map[16] = "Delete"; NodeType.Delete = 16; NodeType._map[17] = "Await"; NodeType.Await = 17; NodeType._map[18] = "In"; NodeType.In = 18; NodeType._map[19] = "Dot"; NodeType.Dot = 19; NodeType._map[20] = "From"; NodeType.From = 20; NodeType._map[21] = "Is"; NodeType.Is = 21; NodeType._map[22] = "InstOf"; NodeType.InstOf = 22; NodeType._map[23] = "Typeof"; NodeType.Typeof = 23; NodeType._map[24] = "NumberLit"; NodeType.NumberLit = 24; NodeType._map[25] = "Name"; NodeType.Name = 25; NodeType._map[26] = "TypeRef"; NodeType.TypeRef = 26; NodeType._map[27] = "Index"; NodeType.Index = 27; NodeType._map[28] = "Call"; NodeType.Call = 28; NodeType._map[29] = "New"; NodeType.New = 29; NodeType._map[30] = "Asg"; NodeType.Asg = 30; NodeType._map[31] = "AsgAdd"; NodeType.AsgAdd = 31; NodeType._map[32] = "AsgSub"; NodeType.AsgSub = 32; NodeType._map[33] = "AsgDiv"; NodeType.AsgDiv = 33; NodeType._map[34] = "AsgMul"; NodeType.AsgMul = 34; NodeType._map[35] = "AsgMod"; NodeType.AsgMod = 35; NodeType._map[36] = "AsgAnd"; NodeType.AsgAnd = 36; NodeType._map[37] = "AsgXor"; NodeType.AsgXor = 37; NodeType._map[38] = "AsgOr"; NodeType.AsgOr = 38; NodeType._map[39] = "AsgLsh"; NodeType.AsgLsh = 39; NodeType._map[40] = "AsgRsh"; NodeType.AsgRsh = 40; NodeType._map[41] = "AsgRs2"; NodeType.AsgRs2 = 41; NodeType._map[42] = "ConditionalExpression"; NodeType.ConditionalExpression = 42; NodeType._map[43] = "LogOr"; NodeType.LogOr = 43; NodeType._map[44] = "LogAnd"; NodeType.LogAnd = 44; NodeType._map[45] = "Or"; NodeType.Or = 45; NodeType._map[46] = "Xor"; NodeType.Xor = 46; NodeType._map[47] = "And"; NodeType.And = 47; NodeType._map[48] = "Eq"; NodeType.Eq = 48; NodeType._map[49] = "Ne"; NodeType.Ne = 49; NodeType._map[50] = "Eqv"; NodeType.Eqv = 50; NodeType._map[51] = "NEqv"; NodeType.NEqv = 51; NodeType._map[52] = "Lt"; NodeType.Lt = 52; NodeType._map[53] = "Le"; NodeType.Le = 53; NodeType._map[54] = "Gt"; NodeType.Gt = 54; NodeType._map[55] = "Ge"; NodeType.Ge = 55; NodeType._map[56] = "Add"; NodeType.Add = 56; NodeType._map[57] = "Sub"; NodeType.Sub = 57; NodeType._map[58] = "Mul"; NodeType.Mul = 58; NodeType._map[59] = "Div"; NodeType.Div = 59; NodeType._map[60] = "Mod"; NodeType.Mod = 60; NodeType._map[61] = "Lsh"; NodeType.Lsh = 61; NodeType._map[62] = "Rsh"; NodeType.Rsh = 62; NodeType._map[63] = "Rs2"; NodeType.Rs2 = 63; NodeType._map[64] = "Not"; NodeType.Not = 64; NodeType._map[65] = "LogNot"; NodeType.LogNot = 65; NodeType._map[66] = "IncPre"; NodeType.IncPre = 66; NodeType._map[67] = "DecPre"; NodeType.DecPre = 67; NodeType._map[68] = "IncPost"; NodeType.IncPost = 68; NodeType._map[69] = "DecPost"; NodeType.DecPost = 69; NodeType._map[70] = "TypeAssertion"; NodeType.TypeAssertion = 70; NodeType._map[71] = "FuncDecl"; NodeType.FuncDecl = 71; NodeType._map[72] = "Member"; NodeType.Member = 72; NodeType._map[73] = "VarDecl"; NodeType.VarDecl = 73; NodeType._map[74] = "ArgDecl"; NodeType.ArgDecl = 74; NodeType._map[75] = "Return"; NodeType.Return = 75; NodeType._map[76] = "Break"; NodeType.Break = 76; NodeType._map[77] = "Continue"; NodeType.Continue = 77; NodeType._map[78] = "Throw"; NodeType.Throw = 78; NodeType._map[79] = "For"; NodeType.For = 79; NodeType._map[80] = "ForIn"; NodeType.ForIn = 80; NodeType._map[81] = "If"; NodeType.If = 81; NodeType._map[82] = "While"; NodeType.While = 82; NodeType._map[83] = "DoWhile"; NodeType.DoWhile = 83; NodeType._map[84] = "Block"; NodeType.Block = 84; NodeType._map[85] = "Case"; NodeType.Case = 85; NodeType._map[86] = "Switch"; NodeType.Switch = 86; NodeType._map[87] = "Try"; NodeType.Try = 87; NodeType._map[88] = "TryCatch"; NodeType.TryCatch = 88; NodeType._map[89] = "TryFinally"; NodeType.TryFinally = 89; NodeType._map[90] = "Finally"; NodeType.Finally = 90; NodeType._map[91] = "Catch"; NodeType.Catch = 91; NodeType._map[92] = "List"; NodeType.List = 92; NodeType._map[93] = "Script"; NodeType.Script = 93; NodeType._map[94] = "ClassDeclaration"; NodeType.ClassDeclaration = 94; NodeType._map[95] = "InterfaceDeclaration"; NodeType.InterfaceDeclaration = 95; NodeType._map[96] = "ModuleDeclaration"; NodeType.ModuleDeclaration = 96; NodeType._map[97] = "ImportDeclaration"; NodeType.ImportDeclaration = 97; NodeType._map[98] = "With"; NodeType.With = 98; NodeType._map[99] = "Label"; NodeType.Label = 99; NodeType._map[100] = "LabeledStatement"; NodeType.LabeledStatement = 100; NodeType._map[101] = "EBStart"; NodeType.EBStart = 101; NodeType._map[102] = "GotoEB"; NodeType.GotoEB = 102; NodeType._map[103] = "EndCode"; NodeType.EndCode = 103; NodeType._map[104] = "Error"; NodeType.Error = 104; NodeType._map[105] = "Comment"; NodeType.Comment = 105; NodeType._map[106] = "Debugger"; NodeType.Debugger = 106; NodeType.GeneralNode = NodeType.FuncDecl; NodeType.LastAsg = NodeType.AsgRs2; })(TypeScript.NodeType || (TypeScript.NodeType = {})); var NodeType = TypeScript.NodeType; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var BlockIntrinsics = (function () { function BlockIntrinsics() { this.prototype = undefined; this.toString = undefined; this.toLocaleString = undefined; this.valueOf = undefined; this.hasOwnProperty = undefined; this.propertyIsEnumerable = undefined; this.isPrototypeOf = undefined; this["constructor"] = undefined; } return BlockIntrinsics; })(); TypeScript.BlockIntrinsics = BlockIntrinsics; var StringHashTable = (function () { function StringHashTable() { this.itemCount = 0; this.table = (new BlockIntrinsics()); } StringHashTable.prototype.getAllKeys = function () { var result = []; for(var k in this.table) { if(this.table[k] != undefined) { result[result.length] = k; } } return result; }; StringHashTable.prototype.add = function (key, data) { if(this.table[key] != undefined) { return false; } this.table[key] = data; this.itemCount++; return true; }; StringHashTable.prototype.addOrUpdate = function (key, data) { if(this.table[key] != undefined) { this.table[key] = data; return false; } this.table[key] = data; this.itemCount++; return true; }; StringHashTable.prototype.map = function (fn, context) { for(var k in this.table) { var data = this.table[k]; if(data != undefined) { fn(k, this.table[k], context); } } }; StringHashTable.prototype.every = function (fn, context) { for(var k in this.table) { var data = this.table[k]; if(data != undefined) { if(!fn(k, this.table[k], context)) { return false; } } } return true; }; StringHashTable.prototype.some = function (fn, context) { for(var k in this.table) { var data = this.table[k]; if(data != undefined) { if(fn(k, this.table[k], context)) { return true; } } } return false; }; StringHashTable.prototype.count = function () { return this.itemCount; }; StringHashTable.prototype.lookup = function (key) { var data = this.table[key]; if(data != undefined) { return data; } else { return (null); } }; return StringHashTable; })(); TypeScript.StringHashTable = StringHashTable; var DualStringHashTable = (function () { function DualStringHashTable(primaryTable, secondaryTable) { this.primaryTable = primaryTable; this.secondaryTable = secondaryTable; this.insertPrimary = true; } DualStringHashTable.prototype.getAllKeys = function () { return this.primaryTable.getAllKeys().concat(this.secondaryTable.getAllKeys()); }; DualStringHashTable.prototype.add = function (key, data) { if(this.insertPrimary) { return this.primaryTable.add(key, data); } else { return this.secondaryTable.add(key, data); } }; DualStringHashTable.prototype.addOrUpdate = function (key, data) { if(this.insertPrimary) { return this.primaryTable.addOrUpdate(key, data); } else { return this.secondaryTable.addOrUpdate(key, data); } }; DualStringHashTable.prototype.map = function (fn, context) { this.primaryTable.map(fn, context); this.secondaryTable.map(fn, context); }; DualStringHashTable.prototype.every = function (fn, context) { return this.primaryTable.every(fn, context) && this.secondaryTable.every(fn, context); }; DualStringHashTable.prototype.some = function (fn, context) { return this.primaryTable.some(fn, context) || this.secondaryTable.some(fn, context); }; DualStringHashTable.prototype.count = function () { return this.primaryTable.count() + this.secondaryTable.count(); }; DualStringHashTable.prototype.lookup = function (key) { var data = this.primaryTable.lookup(key); if(data != undefined) { return data; } else { return this.secondaryTable.lookup(key); } }; return DualStringHashTable; })(); TypeScript.DualStringHashTable = DualStringHashTable; function numberHashFn(key) { var c2 = 668265261; key = (key ^ 61) ^ (key >>> 16); key = key + (key << 3); key = key ^ (key >>> 4); key = key * c2; key = key ^ (key >>> 15); return key; } TypeScript.numberHashFn = numberHashFn; function combineHashes(key1, key2) { return key2 ^ ((key1 >> 5) + key1); } TypeScript.combineHashes = combineHashes; var HashEntry = (function () { function HashEntry(key, data) { this.key = key; this.data = data; } return HashEntry; })(); TypeScript.HashEntry = HashEntry; var HashTable = (function () { function HashTable(size, hashFn, equalsFn) { this.size = size; this.hashFn = hashFn; this.equalsFn = equalsFn; this.itemCount = 0; this.table = new Array(); for(var i = 0; i < this.size; i++) { this.table[i] = null; } } HashTable.prototype.add = function (key, data) { var current; var entry = new HashEntry(key, data); var val = this.hashFn(key); val = val % this.size; for(current = this.table[val]; current != null; current = current.next) { if(this.equalsFn(key, current.key)) { return false; } } entry.next = this.table[val]; this.table[val] = entry; this.itemCount++; return true; }; HashTable.prototype.remove = function (key) { var current; var val = this.hashFn(key); val = val % this.size; var result = null; var prevEntry = null; for(current = this.table[val]; current != null; current = current.next) { if(this.equalsFn(key, current.key)) { result = current.data; this.itemCount--; if(prevEntry) { prevEntry.next = current.next; } else { this.table[val] = current.next; } break; } prevEntry = current; } return result; }; HashTable.prototype.count = function () { return this.itemCount; }; HashTable.prototype.lookup = function (key) { var current; var val = this.hashFn(key); val = val % this.size; for(current = this.table[val]; current != null; current = current.next) { if(this.equalsFn(key, current.key)) { return (current.data); } } return (null); }; return HashTable; })(); TypeScript.HashTable = HashTable; var SimpleHashTable = (function () { function SimpleHashTable() { this.keys = []; this.values = []; } SimpleHashTable.prototype.lookup = function (key, findValue) { var searchArray = this.keys; if(findValue) { searchArray = this.values; } for(var i = 0; i < searchArray.length; i++) { if(searchArray[i] == key) { return { key: this.keys[i], data: this.values[i] }; } } return null; }; SimpleHashTable.prototype.add = function (key, data) { var lookupData = this.lookup(key); if(lookupData) { return false; } this.keys[this.keys.length] = key; this.values[this.values.length] = data; return true; }; return SimpleHashTable; })(); TypeScript.SimpleHashTable = SimpleHashTable; })(TypeScript || (TypeScript = {})); var __extends = this.__extends || function (d, b) { function __() { this.constructor = d; } __.prototype = b.prototype; d.prototype = new __(); }; var TypeScript; (function (TypeScript) { var ASTSpan = (function () { function ASTSpan() { this.minChar = -1; this.limChar = -1; } return ASTSpan; })(); TypeScript.ASTSpan = ASTSpan; var AST = (function (_super) { __extends(AST, _super); function AST(nodeType) { _super.call(this); this.nodeType = nodeType; this.type = null; this.flags = TypeScript.ASTFlags.Writeable; this.passCreated = TypeScript.CompilerDiagnostics.analysisPass; this.preComments = null; this.postComments = null; this.docComments = null; this.isParenthesized = false; } AST.prototype.isExpression = function () { return false; }; AST.prototype.isStatementOrExpression = function () { return false; }; AST.prototype.isCompoundStatement = function () { return false; }; AST.prototype.isLeaf = function () { return this.isStatementOrExpression() && (!this.isCompoundStatement()); }; AST.prototype.isDeclaration = function () { return false; }; AST.prototype.typeCheck = function (typeFlow) { switch(this.nodeType) { case TypeScript.NodeType.Error: case TypeScript.NodeType.EmptyExpr: { this.type = typeFlow.anyType; break; } case TypeScript.NodeType.This: { return typeFlow.typeCheckThis(this); } case TypeScript.NodeType.Null: { this.type = typeFlow.nullType; break; } case TypeScript.NodeType.False: case TypeScript.NodeType.True: { this.type = typeFlow.booleanType; break; } case TypeScript.NodeType.Super: { return typeFlow.typeCheckSuper(this); } case TypeScript.NodeType.EndCode: case TypeScript.NodeType.Empty: case TypeScript.NodeType.Void: { this.type = typeFlow.voidType; break; } default: { throw new Error("please implement in derived class"); } } return this; }; AST.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); switch(this.nodeType) { case TypeScript.NodeType.This: { emitter.recordSourceMappingStart(this); if(emitter.thisFnc && (TypeScript.hasFlag(emitter.thisFnc.fncFlags, TypeScript.FncFlags.IsFatArrowFunction))) { emitter.writeToOutput("_this"); } else { emitter.writeToOutput("this"); } emitter.recordSourceMappingEnd(this); break; } case TypeScript.NodeType.Null: { emitter.recordSourceMappingStart(this); emitter.writeToOutput("null"); emitter.recordSourceMappingEnd(this); break; } case TypeScript.NodeType.False: { emitter.recordSourceMappingStart(this); emitter.writeToOutput("false"); emitter.recordSourceMappingEnd(this); break; } case TypeScript.NodeType.True: { emitter.recordSourceMappingStart(this); emitter.writeToOutput("true"); emitter.recordSourceMappingEnd(this); break; } case TypeScript.NodeType.Super: { emitter.recordSourceMappingStart(this); emitter.emitSuperReference(); emitter.recordSourceMappingEnd(this); break; } case TypeScript.NodeType.EndCode: case TypeScript.NodeType.Error: case TypeScript.NodeType.EmptyExpr: { break; } case TypeScript.NodeType.Empty: { emitter.recordSourceMappingStart(this); emitter.recordSourceMappingEnd(this); break; } case TypeScript.NodeType.Void: { emitter.recordSourceMappingStart(this); emitter.writeToOutput("void "); emitter.recordSourceMappingEnd(this); break; } default: { throw new Error("please implement in derived class"); } } emitter.emitParensAndCommentsInPlace(this, false); }; AST.prototype.print = function (context) { context.startLine(); var lineCol = { line: -1, col: -1 }; var limLineCol = { line: -1, col: -1 }; if(context.parser !== null) { context.parser.getSourceLineCol(lineCol, this.minChar); context.parser.getSourceLineCol(limLineCol, this.limChar); context.write("(" + lineCol.line + "," + lineCol.col + ")--" + "(" + limLineCol.line + "," + limLineCol.col + "): "); } var lab = this.printLabel(); if(TypeScript.hasFlag(this.flags, TypeScript.ASTFlags.Error)) { lab += " (Error)"; } context.writeLine(lab); }; AST.prototype.printLabel = function () { if(TypeScript.nodeTypeTable[this.nodeType] !== undefined) { return TypeScript.nodeTypeTable[this.nodeType]; } else { return (TypeScript.NodeType)._map[this.nodeType]; } }; AST.prototype.addToControlFlow = function (context) { context.walker.options.goChildren = false; context.addContent(this); }; AST.prototype.netFreeUses = function (container, freeUses) { }; AST.prototype.treeViewLabel = function () { return (TypeScript.NodeType)._map[this.nodeType]; }; AST.getResolvedIdentifierName = function getResolvedIdentifierName(name) { if(!name) { return ""; } var resolved = ""; var start = 0; var i = 0; while(i <= name.length - 6) { if(name.charAt(i) == '\\' && name.charAt(i + 1) == 'u') { var charCode = parseInt(name.substr(i + 2, 4), 16); resolved += name.substr(start, i - start); resolved += String.fromCharCode(charCode); i += 6; start = i; continue; } i++; } resolved += name.substring(start); return resolved; } AST.prototype.getDocComments = function () { if(!this.isDeclaration() || !this.preComments || this.preComments.length == 0) { return []; } if(!this.docComments) { var preCommentsLength = this.preComments.length; var docComments = []; for(var i = preCommentsLength - 1; i >= 0; i--) { if(this.preComments[i].isDocComment()) { var prevDocComment = docComments.length > 0 ? docComments[docComments.length - 1] : null; if(prevDocComment == null || (this.preComments[i].limLine == prevDocComment.minLine || this.preComments[i].limLine + 1 == prevDocComment.minLine)) { docComments.push(this.preComments[i]); continue; } } break; } this.docComments = docComments.reverse(); } return this.docComments; }; return AST; })(ASTSpan); TypeScript.AST = AST; var IncompleteAST = (function (_super) { __extends(IncompleteAST, _super); function IncompleteAST(min, lim) { _super.call(this, TypeScript.NodeType.Error); this.minChar = min; this.limChar = lim; } return IncompleteAST; })(AST); TypeScript.IncompleteAST = IncompleteAST; var ASTList = (function (_super) { __extends(ASTList, _super); function ASTList() { _super.call(this, TypeScript.NodeType.List); this.enclosingScope = null; this.members = new Array(); } ASTList.prototype.addToControlFlow = function (context) { var len = this.members.length; for(var i = 0; i < len; i++) { if(context.noContinuation) { context.addUnreachable(this.members[i]); break; } else { this.members[i] = context.walk(this.members[i], this); } } context.walker.options.goChildren = false; }; ASTList.prototype.append = function (ast) { this.members[this.members.length] = ast; return this; }; ASTList.prototype.appendAll = function (ast) { if(ast.nodeType == TypeScript.NodeType.List) { var list = ast; for(var i = 0, len = list.members.length; i < len; i++) { this.append(list.members[i]); } } else { this.append(ast); } return this; }; ASTList.prototype.emit = function (emitter, tokenId, startLine) { emitter.recordSourceMappingStart(this); emitter.emitJavascriptList(this, null, TypeScript.TokenID.Semicolon, startLine, false, false); emitter.recordSourceMappingEnd(this); }; ASTList.prototype.typeCheck = function (typeFlow) { var len = this.members.length; typeFlow.nestingLevel++; for(var i = 0; i < len; i++) { if(this.members[i]) { this.members[i] = this.members[i].typeCheck(typeFlow); } } typeFlow.nestingLevel--; return this; }; return ASTList; })(AST); TypeScript.ASTList = ASTList; var Identifier = (function (_super) { __extends(Identifier, _super); function Identifier(actualText, hasEscapeSequence) { _super.call(this, TypeScript.NodeType.Name); this.actualText = actualText; this.hasEscapeSequence = hasEscapeSequence; this.sym = null; this.cloId = -1; this.setText(actualText, hasEscapeSequence); } Identifier.prototype.setText = function (actualText, hasEscapeSequence) { this.actualText = actualText; if(hasEscapeSequence) { this.text = AST.getResolvedIdentifierName(actualText); } else { this.text = actualText; } }; Identifier.prototype.isMissing = function () { return false; }; Identifier.prototype.isLeaf = function () { return true; }; Identifier.prototype.treeViewLabel = function () { return "id: " + this.actualText; }; Identifier.prototype.printLabel = function () { if(this.actualText) { return "id: " + this.actualText; } else { return "name node"; } }; Identifier.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckName(this); }; Identifier.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitJavascriptName(this, true); }; Identifier.fromToken = function fromToken(token) { return new Identifier(token.getText(), (token).hasEscapeSequence); } return Identifier; })(AST); TypeScript.Identifier = Identifier; var MissingIdentifier = (function (_super) { __extends(MissingIdentifier, _super); function MissingIdentifier() { _super.call(this, "__missing"); } MissingIdentifier.prototype.isMissing = function () { return true; }; MissingIdentifier.prototype.emit = function (emitter, tokenId, startLine) { }; return MissingIdentifier; })(Identifier); TypeScript.MissingIdentifier = MissingIdentifier; var Label = (function (_super) { __extends(Label, _super); function Label(id) { _super.call(this, TypeScript.NodeType.Label); this.id = id; } Label.prototype.printLabel = function () { return this.id.actualText + ":"; }; Label.prototype.typeCheck = function (typeFlow) { this.type = typeFlow.voidType; return this; }; Label.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.recordSourceMappingStart(this.id); emitter.writeToOutput(this.id.actualText); emitter.recordSourceMappingEnd(this.id); emitter.writeLineToOutput(":"); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; return Label; })(AST); TypeScript.Label = Label; var Expression = (function (_super) { __extends(Expression, _super); function Expression(nodeType) { _super.call(this, nodeType); } Expression.prototype.isExpression = function () { return true; }; Expression.prototype.isStatementOrExpression = function () { return true; }; return Expression; })(AST); TypeScript.Expression = Expression; var UnaryExpression = (function (_super) { __extends(UnaryExpression, _super); function UnaryExpression(nodeType, operand) { _super.call(this, nodeType); this.operand = operand; this.targetType = null; this.castTerm = null; } UnaryExpression.prototype.addToControlFlow = function (context) { _super.prototype.addToControlFlow.call(this, context); if(this.nodeType == TypeScript.NodeType.Throw) { context.returnStmt(); } }; UnaryExpression.prototype.typeCheck = function (typeFlow) { switch(this.nodeType) { case TypeScript.NodeType.Not: { return typeFlow.typeCheckBitNot(this); } case TypeScript.NodeType.LogNot: { return typeFlow.typeCheckLogNot(this); } case TypeScript.NodeType.Pos: case TypeScript.NodeType.Neg: { return typeFlow.typeCheckUnaryNumberOperator(this); } case TypeScript.NodeType.IncPost: case TypeScript.NodeType.IncPre: case TypeScript.NodeType.DecPost: case TypeScript.NodeType.DecPre: { return typeFlow.typeCheckIncOrDec(this); } case TypeScript.NodeType.ArrayLit: { typeFlow.typeCheckArrayLit(this); return this; } case TypeScript.NodeType.ObjectLit: { typeFlow.typeCheckObjectLit(this); return this; } case TypeScript.NodeType.Throw: { this.operand = typeFlow.typeCheck(this.operand); this.type = typeFlow.voidType; return this; } case TypeScript.NodeType.Typeof: { this.operand = typeFlow.typeCheck(this.operand); this.type = typeFlow.stringType; return this; } case TypeScript.NodeType.Delete: { this.operand = typeFlow.typeCheck(this.operand); this.type = typeFlow.booleanType; break; } case TypeScript.NodeType.TypeAssertion: { this.castTerm = typeFlow.typeCheck(this.castTerm); var applyTargetType = !this.operand.isParenthesized; var targetType = applyTargetType ? this.castTerm.type : null; typeFlow.checker.typeCheckWithContextualType(targetType, typeFlow.checker.inProvisionalTypecheckMode(), true, this.operand); typeFlow.castWithCoercion(this.operand, this.castTerm.type, false, true); this.type = this.castTerm.type; return this; } case TypeScript.NodeType.Void: { this.operand = typeFlow.typeCheck(this.operand); this.type = typeFlow.checker.undefinedType; break; } default: { throw new Error("please implement in derived class"); } } return this; }; UnaryExpression.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); switch(this.nodeType) { case TypeScript.NodeType.IncPost: { emitter.emitJavascript(this.operand, TypeScript.TokenID.PlusPlus, false); emitter.writeToOutput("++"); break; } case TypeScript.NodeType.LogNot: { emitter.writeToOutput("!"); emitter.emitJavascript(this.operand, TypeScript.TokenID.Exclamation, false); break; } case TypeScript.NodeType.DecPost: { emitter.emitJavascript(this.operand, TypeScript.TokenID.MinusMinus, false); emitter.writeToOutput("--"); break; } case TypeScript.NodeType.ObjectLit: { emitter.emitObjectLiteral(this.operand); break; } case TypeScript.NodeType.ArrayLit: { emitter.emitArrayLiteral(this.operand); break; } case TypeScript.NodeType.Not: { emitter.writeToOutput("~"); emitter.emitJavascript(this.operand, TypeScript.TokenID.Tilde, false); break; } case TypeScript.NodeType.Neg: { emitter.writeToOutput("-"); if(this.operand.nodeType == TypeScript.NodeType.Neg) { this.operand.isParenthesized = true; } emitter.emitJavascript(this.operand, TypeScript.TokenID.Minus, false); break; } case TypeScript.NodeType.Pos: { emitter.writeToOutput("+"); if(this.operand.nodeType == TypeScript.NodeType.Pos) { this.operand.isParenthesized = true; } emitter.emitJavascript(this.operand, TypeScript.TokenID.Plus, false); break; } case TypeScript.NodeType.IncPre: { emitter.writeToOutput("++"); emitter.emitJavascript(this.operand, TypeScript.TokenID.PlusPlus, false); break; } case TypeScript.NodeType.DecPre: { emitter.writeToOutput("--"); emitter.emitJavascript(this.operand, TypeScript.TokenID.MinusMinus, false); break; } case TypeScript.NodeType.Throw: { emitter.writeToOutput("throw "); emitter.emitJavascript(this.operand, TypeScript.TokenID.Tilde, false); emitter.writeToOutput(";"); break; } case TypeScript.NodeType.Typeof: { emitter.writeToOutput("typeof "); emitter.emitJavascript(this.operand, TypeScript.TokenID.Tilde, false); break; } case TypeScript.NodeType.Delete: { emitter.writeToOutput("delete "); emitter.emitJavascript(this.operand, TypeScript.TokenID.Tilde, false); break; } case TypeScript.NodeType.Void: { emitter.writeToOutput("void "); emitter.emitJavascript(this.operand, TypeScript.TokenID.Tilde, false); break; } case TypeScript.NodeType.TypeAssertion: { emitter.emitJavascript(this.operand, TypeScript.TokenID.Tilde, false); break; } default: { throw new Error("please implement in derived class"); } } emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; return UnaryExpression; })(Expression); TypeScript.UnaryExpression = UnaryExpression; var CallExpression = (function (_super) { __extends(CallExpression, _super); function CallExpression(nodeType, target, arguments) { _super.call(this, nodeType); this.target = target; this.arguments = arguments; this.signature = null; this.minChar = this.target.minChar; } CallExpression.prototype.typeCheck = function (typeFlow) { if(this.nodeType == TypeScript.NodeType.New) { return typeFlow.typeCheckNew(this); } else { return typeFlow.typeCheckCall(this); } }; CallExpression.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); if(this.nodeType == TypeScript.NodeType.New) { emitter.emitNew(this.target, this.arguments); } else { emitter.emitCall(this, this.target, this.arguments); } emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; return CallExpression; })(Expression); TypeScript.CallExpression = CallExpression; var BinaryExpression = (function (_super) { __extends(BinaryExpression, _super); function BinaryExpression(nodeType, operand1, operand2) { _super.call(this, nodeType); this.operand1 = operand1; this.operand2 = operand2; } BinaryExpression.prototype.typeCheck = function (typeFlow) { switch(this.nodeType) { case TypeScript.NodeType.Dot: { return typeFlow.typeCheckDotOperator(this); } case TypeScript.NodeType.Asg: { return typeFlow.typeCheckAsgOperator(this); } case TypeScript.NodeType.Add: case TypeScript.NodeType.Sub: case TypeScript.NodeType.Mul: case TypeScript.NodeType.Div: case TypeScript.NodeType.Mod: case TypeScript.NodeType.Or: case TypeScript.NodeType.And: { return typeFlow.typeCheckArithmeticOperator(this, false); } case TypeScript.NodeType.Xor: { return typeFlow.typeCheckBitwiseOperator(this, false); } case TypeScript.NodeType.Ne: case TypeScript.NodeType.Eq: { var text; if(typeFlow.checker.styleSettings.eqeqeq) { text = TypeScript.nodeTypeTable[this.nodeType]; typeFlow.checker.errorReporter.styleError(this, "use of " + text); } else { if(typeFlow.checker.styleSettings.eqnull) { text = TypeScript.nodeTypeTable[this.nodeType]; if((this.operand2 !== null) && (this.operand2.nodeType == TypeScript.NodeType.Null)) { typeFlow.checker.errorReporter.styleError(this, "use of " + text + " to compare with null"); } } } } case TypeScript.NodeType.Eqv: case TypeScript.NodeType.NEqv: case TypeScript.NodeType.Lt: case TypeScript.NodeType.Le: case TypeScript.NodeType.Ge: case TypeScript.NodeType.Gt: { return typeFlow.typeCheckBooleanOperator(this); } case TypeScript.NodeType.Index: { return typeFlow.typeCheckIndex(this); } case TypeScript.NodeType.Member: { this.type = typeFlow.voidType; return this; } case TypeScript.NodeType.LogOr: { return typeFlow.typeCheckLogOr(this); } case TypeScript.NodeType.LogAnd: { return typeFlow.typeCheckLogAnd(this); } case TypeScript.NodeType.AsgAdd: case TypeScript.NodeType.AsgSub: case TypeScript.NodeType.AsgMul: case TypeScript.NodeType.AsgDiv: case TypeScript.NodeType.AsgMod: case TypeScript.NodeType.AsgOr: case TypeScript.NodeType.AsgAnd: { return typeFlow.typeCheckArithmeticOperator(this, true); } case TypeScript.NodeType.AsgXor: { return typeFlow.typeCheckBitwiseOperator(this, true); } case TypeScript.NodeType.Lsh: case TypeScript.NodeType.Rsh: case TypeScript.NodeType.Rs2: { return typeFlow.typeCheckShift(this, false); } case TypeScript.NodeType.AsgLsh: case TypeScript.NodeType.AsgRsh: case TypeScript.NodeType.AsgRs2: { return typeFlow.typeCheckShift(this, true); } case TypeScript.NodeType.Comma: { return typeFlow.typeCheckCommaOperator(this); } case TypeScript.NodeType.InstOf: { return typeFlow.typeCheckInstOf(this); } case TypeScript.NodeType.In: { return typeFlow.typeCheckInOperator(this); } case TypeScript.NodeType.From: { typeFlow.checker.errorReporter.simpleError(this, "Illegal use of 'from' keyword in binary expression"); break; } default: { throw new Error("please implement in derived class"); } } return this; }; BinaryExpression.prototype.emit = function (emitter, tokenId, startLine) { var binTokenId = TypeScript.nodeTypeToTokTable[this.nodeType]; emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); if(binTokenId != undefined) { emitter.emitJavascript(this.operand1, binTokenId, false); if(TypeScript.tokenTable[binTokenId].text == "instanceof") { emitter.writeToOutput(" instanceof "); } else { if(TypeScript.tokenTable[binTokenId].text == "in") { emitter.writeToOutput(" in "); } else { emitter.writeToOutputTrimmable(" " + TypeScript.tokenTable[binTokenId].text + " "); } } emitter.emitJavascript(this.operand2, binTokenId, false); } else { switch(this.nodeType) { case TypeScript.NodeType.Dot: { if(!emitter.tryEmitConstant(this)) { emitter.emitJavascript(this.operand1, TypeScript.TokenID.Dot, false); emitter.writeToOutput("."); emitter.emitJavascriptName(this.operand2, false); } break; } case TypeScript.NodeType.Index: { emitter.emitIndex(this.operand1, this.operand2); break; } case TypeScript.NodeType.Member: { if(this.operand2.nodeType == TypeScript.NodeType.FuncDecl && (this.operand2).isAccessor()) { var funcDecl = this.operand2; if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.GetAccessor)) { emitter.writeToOutput("get "); } else { emitter.writeToOutput("set "); } emitter.emitJavascript(this.operand1, TypeScript.TokenID.Colon, false); } else { emitter.emitJavascript(this.operand1, TypeScript.TokenID.Colon, false); emitter.writeToOutputTrimmable(": "); } emitter.emitJavascript(this.operand2, TypeScript.TokenID.Comma, false); break; } case TypeScript.NodeType.Comma: { emitter.emitJavascript(this.operand1, TypeScript.TokenID.Comma, false); if(emitter.emitState.inObjectLiteral) { emitter.writeLineToOutput(", "); } else { emitter.writeToOutput(","); } emitter.emitJavascript(this.operand2, TypeScript.TokenID.Comma, false); break; } case TypeScript.NodeType.Is: { throw new Error("should be de-sugared during type check"); } default: { throw new Error("please implement in derived class"); } } } emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; return BinaryExpression; })(Expression); TypeScript.BinaryExpression = BinaryExpression; var ConditionalExpression = (function (_super) { __extends(ConditionalExpression, _super); function ConditionalExpression(operand1, operand2, operand3) { _super.call(this, TypeScript.NodeType.ConditionalExpression); this.operand1 = operand1; this.operand2 = operand2; this.operand3 = operand3; } ConditionalExpression.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckQMark(this); }; ConditionalExpression.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.emitJavascript(this.operand1, TypeScript.TokenID.Question, false); emitter.writeToOutput(" ? "); emitter.emitJavascript(this.operand2, TypeScript.TokenID.Question, false); emitter.writeToOutput(" : "); emitter.emitJavascript(this.operand3, TypeScript.TokenID.Question, false); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; return ConditionalExpression; })(Expression); TypeScript.ConditionalExpression = ConditionalExpression; var NumberLiteral = (function (_super) { __extends(NumberLiteral, _super); function NumberLiteral(value, hasEmptyFraction) { _super.call(this, TypeScript.NodeType.NumberLit); this.value = value; this.hasEmptyFraction = hasEmptyFraction; this.isNegativeZero = false; } NumberLiteral.prototype.typeCheck = function (typeFlow) { this.type = typeFlow.doubleType; return this; }; NumberLiteral.prototype.treeViewLabel = function () { return "num: " + this.printLabel(); }; NumberLiteral.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); if(this.isNegativeZero) { emitter.writeToOutput("-"); } emitter.writeToOutput(this.value.toString()); if(this.hasEmptyFraction) { emitter.writeToOutput(".0"); } emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; NumberLiteral.prototype.printLabel = function () { if(Math.floor(this.value) != this.value) { return this.value.toFixed(2).toString(); } else { if(this.hasEmptyFraction) { return this.value.toString() + ".0"; } else { return this.value.toString(); } } }; return NumberLiteral; })(Expression); TypeScript.NumberLiteral = NumberLiteral; var RegexLiteral = (function (_super) { __extends(RegexLiteral, _super); function RegexLiteral(regex) { _super.call(this, TypeScript.NodeType.Regex); this.regex = regex; } RegexLiteral.prototype.typeCheck = function (typeFlow) { this.type = typeFlow.regexType; return this; }; RegexLiteral.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.writeToOutput(this.regex.toString()); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; return RegexLiteral; })(Expression); TypeScript.RegexLiteral = RegexLiteral; var StringLiteral = (function (_super) { __extends(StringLiteral, _super); function StringLiteral(text) { _super.call(this, TypeScript.NodeType.QString); this.text = text; } StringLiteral.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.emitStringLiteral(this.text); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; StringLiteral.prototype.typeCheck = function (typeFlow) { this.type = typeFlow.stringType; return this; }; StringLiteral.prototype.treeViewLabel = function () { return "st: " + this.text; }; StringLiteral.prototype.printLabel = function () { return this.text; }; return StringLiteral; })(Expression); TypeScript.StringLiteral = StringLiteral; var ModuleElement = (function (_super) { __extends(ModuleElement, _super); function ModuleElement(nodeType) { _super.call(this, nodeType); } return ModuleElement; })(AST); TypeScript.ModuleElement = ModuleElement; var ImportDeclaration = (function (_super) { __extends(ImportDeclaration, _super); function ImportDeclaration(id, alias) { _super.call(this, TypeScript.NodeType.ImportDeclaration); this.id = id; this.alias = alias; this.varFlags = TypeScript.VarFlags.None; this.isDynamicImport = false; } ImportDeclaration.prototype.isStatementOrExpression = function () { return true; }; ImportDeclaration.prototype.isDeclaration = function () { return true; }; ImportDeclaration.prototype.emit = function (emitter, tokenId, startLine) { var mod = this.alias.type; if(!this.isDynamicImport || (this.id.sym && !(this.id.sym).onlyReferencedAsTypeRef)) { var prevModAliasId = emitter.modAliasId; var prevFirstModAlias = emitter.firstModAlias; emitter.recordSourceMappingStart(this); emitter.emitParensAndCommentsInPlace(this, true); emitter.writeToOutput("var " + this.id.actualText + " = "); emitter.modAliasId = this.id.actualText; emitter.firstModAlias = this.firstAliasedModToString(); emitter.emitJavascript(this.alias, TypeScript.TokenID.Tilde, false); if(!this.isDynamicImport) { emitter.writeToOutput(";"); } emitter.emitParensAndCommentsInPlace(this, false); emitter.recordSourceMappingEnd(this); emitter.modAliasId = prevModAliasId; emitter.firstModAlias = prevFirstModAlias; } }; ImportDeclaration.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckImportDecl(this); }; ImportDeclaration.prototype.getAliasName = function (aliasAST) { if (typeof aliasAST === "undefined") { aliasAST = this.alias; } if(aliasAST.nodeType == TypeScript.NodeType.Name) { return (aliasAST).actualText; } else { var dotExpr = aliasAST; return this.getAliasName(dotExpr.operand1) + "." + this.getAliasName(dotExpr.operand2); } }; ImportDeclaration.prototype.firstAliasedModToString = function () { if(this.alias.nodeType == TypeScript.NodeType.Name) { return (this.alias).actualText; } else { var dotExpr = this.alias; var firstMod = dotExpr.operand1; return firstMod.actualText; } }; return ImportDeclaration; })(ModuleElement); TypeScript.ImportDeclaration = ImportDeclaration; var BoundDecl = (function (_super) { __extends(BoundDecl, _super); function BoundDecl(id, nodeType, nestingLevel) { _super.call(this, nodeType); this.id = id; this.nestingLevel = nestingLevel; this.init = null; this.typeExpr = null; this.varFlags = TypeScript.VarFlags.None; this.sym = null; } BoundDecl.prototype.isDeclaration = function () { return true; }; BoundDecl.prototype.isStatementOrExpression = function () { return true; }; BoundDecl.prototype.isPrivate = function () { return TypeScript.hasFlag(this.varFlags, TypeScript.VarFlags.Private); }; BoundDecl.prototype.isPublic = function () { return TypeScript.hasFlag(this.varFlags, TypeScript.VarFlags.Public); }; BoundDecl.prototype.isProperty = function () { return TypeScript.hasFlag(this.varFlags, TypeScript.VarFlags.Property); }; BoundDecl.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckBoundDecl(this); }; BoundDecl.prototype.printLabel = function () { return this.treeViewLabel(); }; return BoundDecl; })(AST); TypeScript.BoundDecl = BoundDecl; var VarDecl = (function (_super) { __extends(VarDecl, _super); function VarDecl(id, nest) { _super.call(this, id, TypeScript.NodeType.VarDecl, nest); } VarDecl.prototype.isAmbient = function () { return TypeScript.hasFlag(this.varFlags, TypeScript.VarFlags.Ambient); }; VarDecl.prototype.isExported = function () { return TypeScript.hasFlag(this.varFlags, TypeScript.VarFlags.Exported); }; VarDecl.prototype.isStatic = function () { return TypeScript.hasFlag(this.varFlags, TypeScript.VarFlags.Static); }; VarDecl.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitJavascriptVarDecl(this, tokenId); }; VarDecl.prototype.treeViewLabel = function () { return "var " + this.id.actualText; }; return VarDecl; })(BoundDecl); TypeScript.VarDecl = VarDecl; var ArgDecl = (function (_super) { __extends(ArgDecl, _super); function ArgDecl(id) { _super.call(this, id, TypeScript.NodeType.ArgDecl, 0); this.isOptional = false; this.parameterPropertySym = null; } ArgDecl.prototype.isOptionalArg = function () { return this.isOptional || this.init; }; ArgDecl.prototype.treeViewLabel = function () { return "arg: " + this.id.actualText; }; ArgDecl.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.writeToOutput(this.id.actualText); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; return ArgDecl; })(BoundDecl); TypeScript.ArgDecl = ArgDecl; var internalId = 0; var FuncDecl = (function (_super) { __extends(FuncDecl, _super); function FuncDecl(name, bod, isConstructor, arguments, vars, scopes, statics, nodeType) { _super.call(this, nodeType); this.name = name; this.bod = bod; this.isConstructor = isConstructor; this.arguments = arguments; this.vars = vars; this.scopes = scopes; this.statics = statics; this.hint = null; this.fncFlags = TypeScript.FncFlags.None; this.returnTypeAnnotation = null; this.variableArgList = false; this.jumpRefs = null; this.internalNameCache = null; this.tmp1Declared = false; this.enclosingFnc = null; this.freeVariables = []; this.unitIndex = -1; this.classDecl = null; this.boundToProperty = null; this.isOverload = false; this.innerStaticFuncs = []; this.isTargetTypedAsMethod = false; this.isInlineCallLiteral = false; this.accessorSymbol = null; this.leftCurlyCount = 0; this.rightCurlyCount = 0; this.returnStatementsWithExpressions = []; this.scopeType = null; this.endingToken = null; } FuncDecl.prototype.isDeclaration = function () { return true; }; FuncDecl.prototype.internalName = function () { if(this.internalNameCache == null) { var extName = this.getNameText(); if(extName) { this.internalNameCache = "_internal_" + extName; } else { this.internalNameCache = "_internal_" + internalId++; } } return this.internalNameCache; }; FuncDecl.prototype.hasSelfReference = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.HasSelfReference); }; FuncDecl.prototype.setHasSelfReference = function () { this.fncFlags |= TypeScript.FncFlags.HasSelfReference; }; FuncDecl.prototype.hasSuperReferenceInFatArrowFunction = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.HasSuperReferenceInFatArrowFunction); }; FuncDecl.prototype.setHasSuperReferenceInFatArrowFunction = function () { this.fncFlags |= TypeScript.FncFlags.HasSuperReferenceInFatArrowFunction; }; FuncDecl.prototype.addCloRef = function (id, sym) { if(this.envids == null) { this.envids = new Array(); } this.envids[this.envids.length] = id; var outerFnc = this.enclosingFnc; if(sym) { while(outerFnc && (outerFnc.type.symbol != sym.container)) { outerFnc.addJumpRef(sym); outerFnc = outerFnc.enclosingFnc; } } return this.envids.length - 1; }; FuncDecl.prototype.addJumpRef = function (sym) { if(this.jumpRefs == null) { this.jumpRefs = new Array(); } var id = new Identifier(sym.name); this.jumpRefs[this.jumpRefs.length] = id; id.sym = sym; id.cloId = this.addCloRef(id, null); }; FuncDecl.prototype.buildControlFlow = function () { var entry = new TypeScript.BasicBlock(); var exit = new TypeScript.BasicBlock(); var context = new TypeScript.ControlFlowContext(entry, exit); var controlFlowPrefix = function (ast, parent, walker) { ast.addToControlFlow(walker.state); return ast; }; var walker = TypeScript.getAstWalkerFactory().getWalker(controlFlowPrefix, null, null, context); context.walker = walker; walker.walk(this.bod, this); return context; }; FuncDecl.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckFunction(this); }; FuncDecl.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitJavascriptFunction(this); }; FuncDecl.prototype.getNameText = function () { if(this.name) { return this.name.actualText; } else { return this.hint; } }; FuncDecl.prototype.isMethod = function () { return (this.fncFlags & TypeScript.FncFlags.Method) != TypeScript.FncFlags.None; }; FuncDecl.prototype.isCallMember = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.CallMember); }; FuncDecl.prototype.isConstructMember = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.ConstructMember); }; FuncDecl.prototype.isIndexerMember = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.IndexerMember); }; FuncDecl.prototype.isSpecialFn = function () { return this.isCallMember() || this.isIndexerMember() || this.isConstructMember(); }; FuncDecl.prototype.isAnonymousFn = function () { return this.name === null; }; FuncDecl.prototype.isAccessor = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.GetAccessor) || TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.SetAccessor); }; FuncDecl.prototype.isGetAccessor = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.GetAccessor); }; FuncDecl.prototype.isSetAccessor = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.SetAccessor); }; FuncDecl.prototype.isAmbient = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.Ambient); }; FuncDecl.prototype.isExported = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.Exported); }; FuncDecl.prototype.isPrivate = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.Private); }; FuncDecl.prototype.isPublic = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.Public); }; FuncDecl.prototype.isStatic = function () { return TypeScript.hasFlag(this.fncFlags, TypeScript.FncFlags.Static); }; FuncDecl.prototype.treeViewLabel = function () { if(this.name == null) { return "funcExpr"; } else { return "func: " + this.name.actualText; } }; FuncDecl.prototype.ClearFlags = function () { this.fncFlags = TypeScript.FncFlags.None; }; FuncDecl.prototype.isSignature = function () { return (this.fncFlags & TypeScript.FncFlags.Signature) != TypeScript.FncFlags.None; }; return FuncDecl; })(AST); TypeScript.FuncDecl = FuncDecl; var LocationInfo = (function () { function LocationInfo(filename, lineMap, unitIndex) { this.filename = filename; this.lineMap = lineMap; this.unitIndex = unitIndex; } return LocationInfo; })(); TypeScript.LocationInfo = LocationInfo; TypeScript.unknownLocationInfo = new LocationInfo("unknown", null, -1); var Script = (function (_super) { __extends(Script, _super); function Script(vars, scopes) { _super.call(this, new Identifier("script"), null, false, null, vars, scopes, null, TypeScript.NodeType.Script); this.locationInfo = null; this.referencedFiles = []; this.requiresGlobal = false; this.requiresExtendsBlock = false; this.isResident = false; this.isDeclareFile = false; this.hasBeenTypeChecked = false; this.topLevelMod = null; this.leftCurlyCount = 0; this.rightCurlyCount = 0; this.containsUnicodeChar = false; this.containsUnicodeCharInComment = false; this.externallyVisibleImportedSymbols = []; this.vars = vars; this.scopes = scopes; } Script.prototype.setCachedEmitRequired = function (value) { this.cachedEmitRequired = value; return this.cachedEmitRequired; }; Script.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckScript(this); }; Script.prototype.treeViewLabel = function () { return "Script"; }; Script.prototype.emitRequired = function (emitOptions) { if(this.cachedEmitRequired != undefined) { return this.cachedEmitRequired; } if(!this.isDeclareFile && !this.isResident && this.bod) { for(var i = 0, len = this.bod.members.length; i < len; i++) { var stmt = this.bod.members[i]; if(stmt.nodeType == TypeScript.NodeType.ModuleDeclaration) { if(!TypeScript.hasFlag((stmt).modFlags, TypeScript.ModuleFlags.ShouldEmitModuleDecl | TypeScript.ModuleFlags.Ambient)) { return this.setCachedEmitRequired(true); } } else { if(stmt.nodeType == TypeScript.NodeType.ClassDeclaration) { if(!TypeScript.hasFlag((stmt).varFlags, TypeScript.VarFlags.Ambient)) { return this.setCachedEmitRequired(true); } } else { if(stmt.nodeType == TypeScript.NodeType.VarDecl) { if(!TypeScript.hasFlag((stmt).varFlags, TypeScript.VarFlags.Ambient)) { return this.setCachedEmitRequired(true); } } else { if(stmt.nodeType == TypeScript.NodeType.FuncDecl) { if(!(stmt).isSignature()) { return this.setCachedEmitRequired(true); } } else { if(stmt.nodeType != TypeScript.NodeType.InterfaceDeclaration && stmt.nodeType != TypeScript.NodeType.Empty) { return this.setCachedEmitRequired(true); } } } } } } if(emitOptions.emitComments && ((this.bod.preComments && this.bod.preComments.length > 0) || (this.bod.postComments && this.bod.postComments.length > 0))) { return this.setCachedEmitRequired(true); } } return this.setCachedEmitRequired(false); }; Script.prototype.emit = function (emitter, tokenId, startLine) { if(this.emitRequired(emitter.emitOptions)) { emitter.emitParensAndCommentsInPlace(this.bod, true); emitter.emitJavascriptList(this.bod, null, TypeScript.TokenID.Semicolon, true, false, false, true, this.requiresExtendsBlock); emitter.emitParensAndCommentsInPlace(this.bod, false); } }; Script.prototype.AddExternallyVisibleImportedSymbol = function (symbol, checker) { if(this.isExternallyVisibleSymbol(symbol)) { return; } if(!symbol.getType().symbol.isExternallyVisible(checker)) { var quotes = ""; var moduleName = symbol.getType().symbol.prettyName; if(!TypeScript.isQuoted(moduleName)) { quotes = "'"; } checker.errorReporter.simpleError(symbol.declAST, "Externally visible import statement uses non exported module " + quotes + moduleName + quotes); } this.externallyVisibleImportedSymbols.push(symbol); }; Script.prototype.isExternallyVisibleSymbol = function (symbol) { for(var i = 0; i < this.externallyVisibleImportedSymbols.length; i++) { if(this.externallyVisibleImportedSymbols[i] == symbol) { return true; } } return false; }; return Script; })(FuncDecl); TypeScript.Script = Script; var NamedDeclaration = (function (_super) { __extends(NamedDeclaration, _super); function NamedDeclaration(nodeType, name, members) { _super.call(this, nodeType); this.name = name; this.members = members; this.leftCurlyCount = 0; this.rightCurlyCount = 0; } NamedDeclaration.prototype.isDeclaration = function () { return true; }; return NamedDeclaration; })(ModuleElement); TypeScript.NamedDeclaration = NamedDeclaration; var ModuleDeclaration = (function (_super) { __extends(ModuleDeclaration, _super); function ModuleDeclaration(name, members, vars, scopes, endingToken) { _super.call(this, TypeScript.NodeType.ModuleDeclaration, name, members); this.endingToken = endingToken; this.modFlags = TypeScript.ModuleFlags.ShouldEmitModuleDecl; this.amdDependencies = []; this.containsUnicodeChar = false; this.containsUnicodeCharInComment = false; this.vars = vars; this.scopes = scopes; this.prettyName = this.name.actualText; } ModuleDeclaration.prototype.isExported = function () { return TypeScript.hasFlag(this.modFlags, TypeScript.ModuleFlags.Exported); }; ModuleDeclaration.prototype.isAmbient = function () { return TypeScript.hasFlag(this.modFlags, TypeScript.ModuleFlags.Ambient); }; ModuleDeclaration.prototype.isEnum = function () { return TypeScript.hasFlag(this.modFlags, TypeScript.ModuleFlags.IsEnum); }; ModuleDeclaration.prototype.recordNonInterface = function () { this.modFlags &= ~TypeScript.ModuleFlags.ShouldEmitModuleDecl; }; ModuleDeclaration.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckModule(this); }; ModuleDeclaration.prototype.emit = function (emitter, tokenId, startLine) { if(!TypeScript.hasFlag(this.modFlags, TypeScript.ModuleFlags.ShouldEmitModuleDecl)) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.emitJavascriptModule(this); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); } }; return ModuleDeclaration; })(NamedDeclaration); TypeScript.ModuleDeclaration = ModuleDeclaration; var TypeDeclaration = (function (_super) { __extends(TypeDeclaration, _super); function TypeDeclaration(nodeType, name, extendsList, implementsList, members) { _super.call(this, nodeType, name, members); this.extendsList = extendsList; this.implementsList = implementsList; this.varFlags = TypeScript.VarFlags.None; } TypeDeclaration.prototype.isExported = function () { return TypeScript.hasFlag(this.varFlags, TypeScript.VarFlags.Exported); }; TypeDeclaration.prototype.isAmbient = function () { return TypeScript.hasFlag(this.varFlags, TypeScript.VarFlags.Ambient); }; return TypeDeclaration; })(NamedDeclaration); TypeScript.TypeDeclaration = TypeDeclaration; var ClassDeclaration = (function (_super) { __extends(ClassDeclaration, _super); function ClassDeclaration(name, members, extendsList, implementsList) { _super.call(this, TypeScript.NodeType.ClassDeclaration, name, extendsList, implementsList, members); this.knownMemberNames = { }; this.constructorDecl = null; this.constructorNestingLevel = 0; this.endingToken = null; } ClassDeclaration.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckClass(this); }; ClassDeclaration.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitJavascriptClass(this); }; return ClassDeclaration; })(TypeDeclaration); TypeScript.ClassDeclaration = ClassDeclaration; var InterfaceDeclaration = (function (_super) { __extends(InterfaceDeclaration, _super); function InterfaceDeclaration(name, members, extendsList, implementsList) { _super.call(this, TypeScript.NodeType.InterfaceDeclaration, name, extendsList, implementsList, members); } InterfaceDeclaration.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckInterface(this); }; InterfaceDeclaration.prototype.emit = function (emitter, tokenId, startLine) { }; return InterfaceDeclaration; })(TypeDeclaration); TypeScript.InterfaceDeclaration = InterfaceDeclaration; var Statement = (function (_super) { __extends(Statement, _super); function Statement(nodeType) { _super.call(this, nodeType); this.flags |= TypeScript.ASTFlags.IsStatement; } Statement.prototype.isLoop = function () { return false; }; Statement.prototype.isStatementOrExpression = function () { return true; }; Statement.prototype.isCompoundStatement = function () { return this.isLoop(); }; Statement.prototype.typeCheck = function (typeFlow) { this.type = typeFlow.voidType; return this; }; return Statement; })(ModuleElement); TypeScript.Statement = Statement; var LabeledStatement = (function (_super) { __extends(LabeledStatement, _super); function LabeledStatement(labels, stmt) { _super.call(this, TypeScript.NodeType.LabeledStatement); this.labels = labels; this.stmt = stmt; } LabeledStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); if(this.labels) { var labelsLen = this.labels.members.length; for(var i = 0; i < labelsLen; i++) { this.labels.members[i].emit(emitter, tokenId, startLine); } } this.stmt.emit(emitter, tokenId, true); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; LabeledStatement.prototype.typeCheck = function (typeFlow) { typeFlow.typeCheck(this.labels); this.stmt = this.stmt.typeCheck(typeFlow); return this; }; LabeledStatement.prototype.addToControlFlow = function (context) { var beforeBB = context.current; var bb = new TypeScript.BasicBlock(); context.current = bb; beforeBB.addSuccessor(bb); }; return LabeledStatement; })(Statement); TypeScript.LabeledStatement = LabeledStatement; var Block = (function (_super) { __extends(Block, _super); function Block(statements, isStatementBlock) { _super.call(this, TypeScript.NodeType.Block); this.statements = statements; this.isStatementBlock = isStatementBlock; } Block.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); if(this.isStatementBlock) { emitter.writeLineToOutput(" {"); emitter.indenter.increaseIndent(); } else { emitter.setInVarBlock(this.statements.members.length); } var temp = emitter.setInObjectLiteral(false); if(this.statements) { emitter.emitJavascriptList(this.statements, null, TypeScript.TokenID.Semicolon, true, false, false); } if(this.isStatementBlock) { emitter.indenter.decreaseIndent(); emitter.emitIndent(); emitter.writeToOutput("}"); } emitter.setInObjectLiteral(temp); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; Block.prototype.addToControlFlow = function (context) { var afterIfNeeded = new TypeScript.BasicBlock(); context.pushStatement(this, context.current, afterIfNeeded); if(this.statements) { context.walk(this.statements, this); } context.walker.options.goChildren = false; context.popStatement(); if(afterIfNeeded.predecessors.length > 0) { context.current.addSuccessor(afterIfNeeded); context.current = afterIfNeeded; } }; Block.prototype.typeCheck = function (typeFlow) { if(!typeFlow.checker.styleSettings.emptyBlocks) { if((this.statements === null) || (this.statements.members.length == 0)) { typeFlow.checker.errorReporter.styleError(this, "empty block"); } } typeFlow.typeCheck(this.statements); return this; }; return Block; })(Statement); TypeScript.Block = Block; var Jump = (function (_super) { __extends(Jump, _super); function Jump(nodeType) { _super.call(this, nodeType); this.target = null; this.resolvedTarget = null; } Jump.prototype.hasExplicitTarget = function () { return (this.target); }; Jump.prototype.setResolvedTarget = function (parser, stmt) { if(stmt.isLoop()) { this.resolvedTarget = stmt; return true; } if(this.nodeType === TypeScript.NodeType.Continue) { parser.reportParseError("continue statement applies only to loops"); return false; } else { if((stmt.nodeType == TypeScript.NodeType.Switch) || this.hasExplicitTarget()) { this.resolvedTarget = stmt; return true; } else { parser.reportParseError("break statement with no label can apply only to a loop or switch statement"); return false; } } }; Jump.prototype.addToControlFlow = function (context) { _super.prototype.addToControlFlow.call(this, context); context.unconditionalBranch(this.resolvedTarget, (this.nodeType == TypeScript.NodeType.Continue)); }; Jump.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); if(this.nodeType == TypeScript.NodeType.Break) { emitter.writeToOutput("break"); } else { emitter.writeToOutput("continue"); } if(this.hasExplicitTarget()) { emitter.writeToOutput(" " + this.target); } emitter.recordSourceMappingEnd(this); emitter.writeToOutput(";"); emitter.emitParensAndCommentsInPlace(this, false); }; return Jump; })(Statement); TypeScript.Jump = Jump; var WhileStatement = (function (_super) { __extends(WhileStatement, _super); function WhileStatement(cond) { _super.call(this, TypeScript.NodeType.While); this.cond = cond; this.body = null; } WhileStatement.prototype.isLoop = function () { return true; }; WhileStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); var temp = emitter.setInObjectLiteral(false); emitter.writeToOutput("while("); emitter.emitJavascript(this.cond, TypeScript.TokenID.While, false); emitter.writeToOutput(")"); emitter.emitJavascriptStatements(this.body, false); emitter.setInObjectLiteral(temp); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; WhileStatement.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckWhile(this); }; WhileStatement.prototype.addToControlFlow = function (context) { var loopHeader = context.current; var loopStart = new TypeScript.BasicBlock(); var afterLoop = new TypeScript.BasicBlock(); loopHeader.addSuccessor(loopStart); context.current = loopStart; context.addContent(this.cond); var condBlock = context.current; var targetInfo = null; if(this.body) { context.current = new TypeScript.BasicBlock(); condBlock.addSuccessor(context.current); context.pushStatement(this, loopStart, afterLoop); context.walk(this.body, this); targetInfo = context.popStatement(); } if(!(context.noContinuation)) { var loopEnd = context.current; loopEnd.addSuccessor(loopStart); } context.current = afterLoop; condBlock.addSuccessor(afterLoop); context.noContinuation = false; context.walker.options.goChildren = false; }; return WhileStatement; })(Statement); TypeScript.WhileStatement = WhileStatement; var DoWhileStatement = (function (_super) { __extends(DoWhileStatement, _super); function DoWhileStatement() { _super.call(this, TypeScript.NodeType.DoWhile); this.body = null; this.whileAST = null; this.cond = null; } DoWhileStatement.prototype.isLoop = function () { return true; }; DoWhileStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); var temp = emitter.setInObjectLiteral(false); emitter.writeToOutput("do"); emitter.emitJavascriptStatements(this.body, true); emitter.recordSourceMappingStart(this.whileAST); emitter.writeToOutput("while"); emitter.recordSourceMappingEnd(this.whileAST); emitter.writeToOutput('('); emitter.emitJavascript(this.cond, TypeScript.TokenID.CloseParen, false); emitter.writeToOutput(")"); emitter.setInObjectLiteral(temp); emitter.recordSourceMappingEnd(this); emitter.writeToOutput(";"); emitter.emitParensAndCommentsInPlace(this, false); }; DoWhileStatement.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckDoWhile(this); }; DoWhileStatement.prototype.addToControlFlow = function (context) { var loopHeader = context.current; var loopStart = new TypeScript.BasicBlock(); var afterLoop = new TypeScript.BasicBlock(); loopHeader.addSuccessor(loopStart); context.current = loopStart; var targetInfo = null; if(this.body) { context.pushStatement(this, loopStart, afterLoop); context.walk(this.body, this); targetInfo = context.popStatement(); } if(!(context.noContinuation)) { var loopEnd = context.current; loopEnd.addSuccessor(loopStart); context.addContent(this.cond); context.current = afterLoop; loopEnd.addSuccessor(afterLoop); } else { context.addUnreachable(this.cond); } context.walker.options.goChildren = false; }; return DoWhileStatement; })(Statement); TypeScript.DoWhileStatement = DoWhileStatement; var IfStatement = (function (_super) { __extends(IfStatement, _super); function IfStatement(cond) { _super.call(this, TypeScript.NodeType.If); this.cond = cond; this.elseBod = null; this.statement = new ASTSpan(); } IfStatement.prototype.isCompoundStatement = function () { return true; }; IfStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); var temp = emitter.setInObjectLiteral(false); emitter.recordSourceMappingStart(this.statement); emitter.writeToOutput("if("); emitter.emitJavascript(this.cond, TypeScript.TokenID.If, false); emitter.writeToOutput(")"); emitter.recordSourceMappingEnd(this.statement); emitter.emitJavascriptStatements(this.thenBod, true); if(this.elseBod) { if(this.elseBod.nodeType === TypeScript.NodeType.If) { emitter.writeToOutput(" else "); this.elseBod.emit(emitter, tokenId, false); } else { emitter.writeToOutput(" else"); emitter.emitJavascriptStatements(this.elseBod, true); } } emitter.setInObjectLiteral(temp); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; IfStatement.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckIf(this); }; IfStatement.prototype.addToControlFlow = function (context) { this.cond.addToControlFlow(context); var afterIf = new TypeScript.BasicBlock(); var beforeIf = context.current; context.pushStatement(this, beforeIf, afterIf); var hasContinuation = false; context.current = new TypeScript.BasicBlock(); beforeIf.addSuccessor(context.current); context.walk(this.thenBod, this); if(!context.noContinuation) { hasContinuation = true; context.current.addSuccessor(afterIf); } if(this.elseBod) { context.current = new TypeScript.BasicBlock(); context.noContinuation = false; beforeIf.addSuccessor(context.current); context.walk(this.elseBod, this); if(!context.noContinuation) { hasContinuation = true; context.current.addSuccessor(afterIf); } else { if(hasContinuation) { context.noContinuation = false; } } } else { beforeIf.addSuccessor(afterIf); context.noContinuation = false; hasContinuation = true; } var targetInfo = context.popStatement(); if(afterIf.predecessors.length > 0) { context.noContinuation = false; hasContinuation = true; } if(hasContinuation) { context.current = afterIf; } context.walker.options.goChildren = false; }; return IfStatement; })(Statement); TypeScript.IfStatement = IfStatement; var ReturnStatement = (function (_super) { __extends(ReturnStatement, _super); function ReturnStatement() { _super.call(this, TypeScript.NodeType.Return); this.returnExpression = null; } ReturnStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); var temp = emitter.setInObjectLiteral(false); if(this.returnExpression) { emitter.writeToOutput("return "); emitter.emitJavascript(this.returnExpression, TypeScript.TokenID.Semicolon, false); if(this.returnExpression.nodeType === TypeScript.NodeType.FuncDecl) { emitter.writeToOutput(";"); } } else { emitter.writeToOutput("return;"); } emitter.setInObjectLiteral(temp); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; ReturnStatement.prototype.addToControlFlow = function (context) { _super.prototype.addToControlFlow.call(this, context); context.returnStmt(); }; ReturnStatement.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckReturn(this); }; return ReturnStatement; })(Statement); TypeScript.ReturnStatement = ReturnStatement; var EndCode = (function (_super) { __extends(EndCode, _super); function EndCode() { _super.call(this, TypeScript.NodeType.EndCode); } return EndCode; })(AST); TypeScript.EndCode = EndCode; var ForInStatement = (function (_super) { __extends(ForInStatement, _super); function ForInStatement(lval, obj) { _super.call(this, TypeScript.NodeType.ForIn); this.lval = lval; this.obj = obj; this.statement = new ASTSpan(); if(this.lval && (this.lval.nodeType == TypeScript.NodeType.VarDecl)) { (this.lval).varFlags |= TypeScript.VarFlags.AutoInit; } } ForInStatement.prototype.isLoop = function () { return true; }; ForInStatement.prototype.isFiltered = function () { if(this.body) { var singleItem = null; if(this.body.nodeType == TypeScript.NodeType.List) { var stmts = this.body; if(stmts.members.length == 1) { singleItem = stmts.members[0]; } } else { singleItem = this.body; } if(singleItem !== null) { if(singleItem.nodeType == TypeScript.NodeType.Block) { var block = singleItem; if((block.statements !== null) && (block.statements.members.length == 1)) { singleItem = block.statements.members[0]; } } if(singleItem.nodeType == TypeScript.NodeType.If) { var cond = (singleItem).cond; if(cond.nodeType == TypeScript.NodeType.Call) { var target = (cond).target; if(target.nodeType == TypeScript.NodeType.Dot) { var binex = target; if((binex.operand1.nodeType == TypeScript.NodeType.Name) && (this.obj.nodeType == TypeScript.NodeType.Name) && ((binex.operand1).actualText == (this.obj).actualText)) { var prop = binex.operand2; if(prop.actualText == "hasOwnProperty") { var args = (cond).arguments; if((args !== null) && (args.members.length == 1)) { var arg = args.members[0]; if((arg.nodeType == TypeScript.NodeType.Name) && (this.lval.nodeType == TypeScript.NodeType.Name)) { if(((this.lval).actualText) == (arg).actualText) { return true; } } } } } } } } } } return false; }; ForInStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); var temp = emitter.setInObjectLiteral(false); emitter.recordSourceMappingStart(this.statement); emitter.writeToOutput("for("); emitter.emitJavascript(this.lval, TypeScript.TokenID.For, false); emitter.writeToOutput(" in "); emitter.emitJavascript(this.obj, TypeScript.TokenID.For, false); emitter.writeToOutput(")"); emitter.recordSourceMappingEnd(this.statement); emitter.emitJavascriptStatements(this.body, true); emitter.setInObjectLiteral(temp); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; ForInStatement.prototype.typeCheck = function (typeFlow) { if(typeFlow.checker.styleSettings.forin) { if(!this.isFiltered()) { typeFlow.checker.errorReporter.styleError(this, "no hasOwnProperty filter"); } } return typeFlow.typeCheckForIn(this); }; ForInStatement.prototype.addToControlFlow = function (context) { if(this.lval) { context.addContent(this.lval); } if(this.obj) { context.addContent(this.obj); } var loopHeader = context.current; var loopStart = new TypeScript.BasicBlock(); var afterLoop = new TypeScript.BasicBlock(); loopHeader.addSuccessor(loopStart); context.current = loopStart; if(this.body) { context.pushStatement(this, loopStart, afterLoop); context.walk(this.body, this); context.popStatement(); } if(!(context.noContinuation)) { var loopEnd = context.current; loopEnd.addSuccessor(loopStart); } context.current = afterLoop; context.noContinuation = false; loopHeader.addSuccessor(afterLoop); context.walker.options.goChildren = false; }; return ForInStatement; })(Statement); TypeScript.ForInStatement = ForInStatement; var ForStatement = (function (_super) { __extends(ForStatement, _super); function ForStatement(init) { _super.call(this, TypeScript.NodeType.For); this.init = init; } ForStatement.prototype.isLoop = function () { return true; }; ForStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); var temp = emitter.setInObjectLiteral(false); emitter.writeToOutput("for("); if(this.init) { if(this.init.nodeType != TypeScript.NodeType.List) { emitter.emitJavascript(this.init, TypeScript.TokenID.For, false); } else { emitter.setInVarBlock((this.init).members.length); emitter.emitJavascriptList(this.init, null, TypeScript.TokenID.For, false, false, false); } } emitter.writeToOutput("; "); emitter.emitJavascript(this.cond, TypeScript.TokenID.For, false); emitter.writeToOutput("; "); emitter.emitJavascript(this.incr, TypeScript.TokenID.For, false); emitter.writeToOutput(")"); emitter.emitJavascriptStatements(this.body, true); emitter.setInObjectLiteral(temp); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; ForStatement.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckFor(this); }; ForStatement.prototype.addToControlFlow = function (context) { if(this.init) { context.addContent(this.init); } var loopHeader = context.current; var loopStart = new TypeScript.BasicBlock(); var afterLoop = new TypeScript.BasicBlock(); loopHeader.addSuccessor(loopStart); context.current = loopStart; var condBlock = null; var continueTarget = loopStart; var incrBB = null; if(this.incr) { incrBB = new TypeScript.BasicBlock(); continueTarget = incrBB; } if(this.cond) { condBlock = context.current; context.addContent(this.cond); context.current = new TypeScript.BasicBlock(); condBlock.addSuccessor(context.current); } var targetInfo = null; if(this.body) { context.pushStatement(this, continueTarget, afterLoop); context.walk(this.body, this); targetInfo = context.popStatement(); } if(this.incr) { if(context.noContinuation) { if(incrBB.predecessors.length == 0) { context.addUnreachable(this.incr); } } else { context.current.addSuccessor(incrBB); context.current = incrBB; context.addContent(this.incr); } } var loopEnd = context.current; if(!(context.noContinuation)) { loopEnd.addSuccessor(loopStart); } if(condBlock) { condBlock.addSuccessor(afterLoop); context.noContinuation = false; } if(afterLoop.predecessors.length > 0) { context.noContinuation = false; context.current = afterLoop; } context.walker.options.goChildren = false; }; return ForStatement; })(Statement); TypeScript.ForStatement = ForStatement; var WithStatement = (function (_super) { __extends(WithStatement, _super); function WithStatement(expr) { _super.call(this, TypeScript.NodeType.With); this.expr = expr; this.withSym = null; } WithStatement.prototype.isCompoundStatement = function () { return true; }; WithStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.writeToOutput("with ("); if(this.expr) { emitter.emitJavascript(this.expr, TypeScript.TokenID.With, false); } emitter.writeToOutput(")"); emitter.emitJavascriptStatements(this.body, true); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; WithStatement.prototype.typeCheck = function (typeFlow) { return typeFlow.typeCheckWith(this); }; return WithStatement; })(Statement); TypeScript.WithStatement = WithStatement; var SwitchStatement = (function (_super) { __extends(SwitchStatement, _super); function SwitchStatement(val) { _super.call(this, TypeScript.NodeType.Switch); this.val = val; this.defaultCase = null; this.statement = new ASTSpan(); } SwitchStatement.prototype.isCompoundStatement = function () { return true; }; SwitchStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); var temp = emitter.setInObjectLiteral(false); emitter.recordSourceMappingStart(this.statement); emitter.writeToOutput("switch("); emitter.emitJavascript(this.val, TypeScript.TokenID.Identifier, false); emitter.writeToOutput(")"); emitter.recordSourceMappingEnd(this.statement); emitter.writeLineToOutput(" {"); emitter.indenter.increaseIndent(); var casesLen = this.caseList.members.length; for(var i = 0; i < casesLen; i++) { var caseExpr = this.caseList.members[i]; emitter.emitJavascript(caseExpr, TypeScript.TokenID.Case, true); } emitter.indenter.decreaseIndent(); emitter.emitIndent(); emitter.writeToOutput("}"); emitter.setInObjectLiteral(temp); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; SwitchStatement.prototype.typeCheck = function (typeFlow) { var len = this.caseList.members.length; this.val = typeFlow.typeCheck(this.val); for(var i = 0; i < len; i++) { this.caseList.members[i] = typeFlow.typeCheck(this.caseList.members[i]); } this.defaultCase = typeFlow.typeCheck(this.defaultCase); this.type = typeFlow.voidType; return this; }; SwitchStatement.prototype.addToControlFlow = function (context) { var condBlock = context.current; context.addContent(this.val); var execBlock = new TypeScript.BasicBlock(); var afterSwitch = new TypeScript.BasicBlock(); condBlock.addSuccessor(execBlock); context.pushSwitch(execBlock); context.current = execBlock; context.pushStatement(this, execBlock, afterSwitch); context.walk(this.caseList, this); context.popSwitch(); var targetInfo = context.popStatement(); var hasCondContinuation = (this.defaultCase == null); if(this.defaultCase == null) { condBlock.addSuccessor(afterSwitch); } if(afterSwitch.predecessors.length > 0) { context.noContinuation = false; context.current = afterSwitch; } else { context.noContinuation = true; } context.walker.options.goChildren = false; }; return SwitchStatement; })(Statement); TypeScript.SwitchStatement = SwitchStatement; var CaseStatement = (function (_super) { __extends(CaseStatement, _super); function CaseStatement() { _super.call(this, TypeScript.NodeType.Case); this.expr = null; } CaseStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); if(this.expr) { emitter.writeToOutput("case "); emitter.emitJavascript(this.expr, TypeScript.TokenID.Identifier, false); } else { emitter.writeToOutput("default"); } emitter.writeToOutput(":"); if(this.body.members.length == 1 && this.body.members[0].nodeType == TypeScript.NodeType.Block) { emitter.emitJavascriptStatements(this.body, false); } else { emitter.writeLineToOutput(""); emitter.indenter.increaseIndent(); emitter.emitBareJavascriptStatements(this.body); emitter.indenter.decreaseIndent(); } emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; CaseStatement.prototype.typeCheck = function (typeFlow) { this.expr = typeFlow.typeCheck(this.expr); typeFlow.typeCheck(this.body); this.type = typeFlow.voidType; return this; }; CaseStatement.prototype.addToControlFlow = function (context) { var execBlock = new TypeScript.BasicBlock(); var sw = context.currentSwitch[context.currentSwitch.length - 1]; if(this.expr) { var exprBlock = new TypeScript.BasicBlock(); context.current = exprBlock; sw.addSuccessor(exprBlock); context.addContent(this.expr); exprBlock.addSuccessor(execBlock); } else { sw.addSuccessor(execBlock); } context.current = execBlock; if(this.body) { context.walk(this.body, this); } context.noContinuation = false; context.walker.options.goChildren = false; }; return CaseStatement; })(Statement); TypeScript.CaseStatement = CaseStatement; var TypeReference = (function (_super) { __extends(TypeReference, _super); function TypeReference(term, arrayCount) { _super.call(this, TypeScript.NodeType.TypeRef); this.term = term; this.arrayCount = arrayCount; } TypeReference.prototype.emit = function (emitter, tokenId, startLine) { throw new Error("should not emit a type ref"); }; TypeReference.prototype.typeCheck = function (typeFlow) { var prevInTCTR = typeFlow.inTypeRefTypeCheck; typeFlow.inTypeRefTypeCheck = true; var typeLink = TypeScript.getTypeLink(this, typeFlow.checker, true); typeFlow.checker.resolveTypeLink(typeFlow.scope, typeLink, false); if(this.term) { typeFlow.typeCheck(this.term); } typeFlow.checkForVoidConstructor(typeLink.type, this); this.type = typeLink.type; if(this.term) { this.term.type = this.type; } typeFlow.inTypeRefTypeCheck = prevInTCTR; return this; }; return TypeReference; })(AST); TypeScript.TypeReference = TypeReference; var TryFinally = (function (_super) { __extends(TryFinally, _super); function TryFinally(tryNode, finallyNode) { _super.call(this, TypeScript.NodeType.TryFinally); this.tryNode = tryNode; this.finallyNode = finallyNode; } TryFinally.prototype.isCompoundStatement = function () { return true; }; TryFinally.prototype.emit = function (emitter, tokenId, startLine) { emitter.recordSourceMappingStart(this); emitter.emitJavascript(this.tryNode, TypeScript.TokenID.Try, false); emitter.emitJavascript(this.finallyNode, TypeScript.TokenID.Finally, false); emitter.recordSourceMappingEnd(this); }; TryFinally.prototype.typeCheck = function (typeFlow) { this.tryNode = typeFlow.typeCheck(this.tryNode); this.finallyNode = typeFlow.typeCheck(this.finallyNode); this.type = typeFlow.voidType; return this; }; TryFinally.prototype.addToControlFlow = function (context) { var afterFinally = new TypeScript.BasicBlock(); context.walk(this.tryNode, this); var finBlock = new TypeScript.BasicBlock(); if(context.current) { context.current.addSuccessor(finBlock); } context.current = finBlock; context.pushStatement(this, null, afterFinally); context.walk(this.finallyNode, this); if(!context.noContinuation && context.current) { context.current.addSuccessor(afterFinally); } if(afterFinally.predecessors.length > 0) { context.current = afterFinally; } else { context.noContinuation = true; } context.popStatement(); context.walker.options.goChildren = false; }; return TryFinally; })(Statement); TypeScript.TryFinally = TryFinally; var TryCatch = (function (_super) { __extends(TryCatch, _super); function TryCatch(tryNode, catchNode) { _super.call(this, TypeScript.NodeType.TryCatch); this.tryNode = tryNode; this.catchNode = catchNode; } TryCatch.prototype.isCompoundStatement = function () { return true; }; TryCatch.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.emitJavascript(this.tryNode, TypeScript.TokenID.Try, false); emitter.emitJavascript(this.catchNode, TypeScript.TokenID.Catch, false); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; TryCatch.prototype.addToControlFlow = function (context) { var beforeTry = context.current; var tryBlock = new TypeScript.BasicBlock(); beforeTry.addSuccessor(tryBlock); context.current = tryBlock; var afterTryCatch = new TypeScript.BasicBlock(); context.pushStatement(this, null, afterTryCatch); context.walk(this.tryNode, this); if(!context.noContinuation) { if(context.current) { context.current.addSuccessor(afterTryCatch); } } context.current = new TypeScript.BasicBlock(); beforeTry.addSuccessor(context.current); context.walk(this.catchNode, this); context.popStatement(); if(!context.noContinuation) { if(context.current) { context.current.addSuccessor(afterTryCatch); } } context.current = afterTryCatch; context.walker.options.goChildren = false; }; TryCatch.prototype.typeCheck = function (typeFlow) { this.tryNode = typeFlow.typeCheck(this.tryNode); this.catchNode = typeFlow.typeCheck(this.catchNode); this.type = typeFlow.voidType; return this; }; return TryCatch; })(Statement); TypeScript.TryCatch = TryCatch; var Try = (function (_super) { __extends(Try, _super); function Try(body) { _super.call(this, TypeScript.NodeType.Try); this.body = body; } Try.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.writeToOutput("try "); emitter.emitJavascript(this.body, TypeScript.TokenID.Try, false); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; Try.prototype.typeCheck = function (typeFlow) { this.body = typeFlow.typeCheck(this.body); return this; }; Try.prototype.addToControlFlow = function (context) { if(this.body) { context.walk(this.body, this); } context.walker.options.goChildren = false; context.noContinuation = false; }; return Try; })(Statement); TypeScript.Try = Try; var Catch = (function (_super) { __extends(Catch, _super); function Catch(param, body) { _super.call(this, TypeScript.NodeType.Catch); this.param = param; this.body = body; this.statement = new ASTSpan(); this.containedScope = null; if(this.param) { this.param.varFlags |= TypeScript.VarFlags.AutoInit; } } Catch.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.writeToOutput(" "); emitter.recordSourceMappingStart(this.statement); emitter.writeToOutput("catch ("); emitter.emitJavascript(this.param, TypeScript.TokenID.OpenParen, false); emitter.writeToOutput(")"); emitter.recordSourceMappingEnd(this.statement); emitter.emitJavascript(this.body, TypeScript.TokenID.Catch, false); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; Catch.prototype.addToControlFlow = function (context) { if(this.param) { context.addContent(this.param); var bodBlock = new TypeScript.BasicBlock(); context.current.addSuccessor(bodBlock); context.current = bodBlock; } if(this.body) { context.walk(this.body, this); } context.noContinuation = false; context.walker.options.goChildren = false; }; Catch.prototype.typeCheck = function (typeFlow) { var prevScope = typeFlow.scope; typeFlow.scope = this.containedScope; this.param = typeFlow.typeCheck(this.param); var exceptVar = new TypeScript.ValueLocation(); var varSym = new TypeScript.VariableSymbol((this.param).id.text, this.param.minChar, typeFlow.checker.locationInfo.unitIndex, exceptVar); exceptVar.symbol = varSym; exceptVar.typeLink = new TypeScript.TypeLink(); exceptVar.typeLink.type = typeFlow.anyType; var thisFnc = typeFlow.thisFnc; if(thisFnc && thisFnc.type) { exceptVar.symbol.container = thisFnc.type.symbol; } else { exceptVar.symbol.container = null; } this.param.sym = exceptVar.symbol; typeFlow.scope.enter(exceptVar.symbol.container, this.param, exceptVar.symbol, typeFlow.checker.errorReporter, false, false, false); this.body = typeFlow.typeCheck(this.body); if(typeFlow.checker.inProvisionalTypecheckMode()) { var table = typeFlow.scope.getTable(); (table).secondaryTable.table[exceptVar.symbol.name] = undefined; } this.type = typeFlow.voidType; typeFlow.scope = prevScope; return this; }; return Catch; })(Statement); TypeScript.Catch = Catch; var Finally = (function (_super) { __extends(Finally, _super); function Finally(body) { _super.call(this, TypeScript.NodeType.Finally); this.body = body; } Finally.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.writeToOutput("finally"); emitter.emitJavascript(this.body, TypeScript.TokenID.Finally, false); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; Finally.prototype.addToControlFlow = function (context) { if(this.body) { context.walk(this.body, this); } context.walker.options.goChildren = false; context.noContinuation = false; }; Finally.prototype.typeCheck = function (typeFlow) { this.body = typeFlow.typeCheck(this.body); return this; }; return Finally; })(Statement); TypeScript.Finally = Finally; var Comment = (function (_super) { __extends(Comment, _super); function Comment(content, isBlockComment, endsLine) { _super.call(this, TypeScript.NodeType.Comment); this.content = content; this.isBlockComment = isBlockComment; this.endsLine = endsLine; this.text = null; this.docCommentText = null; } Comment.prototype.getText = function () { if(this.text == null) { if(this.isBlockComment) { this.text = this.content.split("\n"); for(var i = 0; i < this.text.length; i++) { this.text[i] = this.text[i].replace(/^\s+|\s+$/g, ''); } } else { this.text = [ (this.content.replace(/^\s+|\s+$/g, '')) ]; } } return this.text; }; Comment.prototype.isDocComment = function () { if(this.isBlockComment) { return this.content.charAt(2) == "*"; } return false; }; Comment.prototype.getDocCommentText = function () { if(this.docCommentText == null) { this.docCommentText = Comment.cleanJSDocComment(this.content); } return this.docCommentText; }; Comment.consumeLeadingSpace = function consumeLeadingSpace(line, startIndex, maxSpacesToRemove) { var endIndex = line.length; if(maxSpacesToRemove != undefined) { endIndex = TypeScript.min(startIndex + maxSpacesToRemove, endIndex); } for(; startIndex < endIndex; startIndex++) { var charCode = line.charCodeAt(startIndex); if(charCode != TypeScript.LexCodeSpace && charCode != TypeScript.LexCodeTAB) { return startIndex; } } if(endIndex != line.length) { return endIndex; } return -1; } Comment.isSpaceChar = function isSpaceChar(line, index) { var length = line.length; if(index < length) { var charCode = line.charCodeAt(index); return charCode == TypeScript.LexCodeSpace || charCode == TypeScript.LexCodeTAB; } return index == length; } Comment.cleanDocCommentLine = function cleanDocCommentLine(line, jsDocStyleComment, jsDocLineSpaceToRemove) { var nonSpaceIndex = Comment.consumeLeadingSpace(line, 0); if(nonSpaceIndex != -1) { var jsDocSpacesRemoved = nonSpaceIndex; if(jsDocStyleComment && line.charAt(nonSpaceIndex) == '*') { var startIndex = nonSpaceIndex + 1; nonSpaceIndex = Comment.consumeLeadingSpace(line, startIndex, jsDocLineSpaceToRemove); if(nonSpaceIndex != -1) { jsDocSpacesRemoved = nonSpaceIndex - startIndex; } else { return null; } } return { minChar: nonSpaceIndex, limChar: line.charAt(line.length - 1) == "\r" ? line.length - 1 : line.length, jsDocSpacesRemoved: jsDocSpacesRemoved }; } return null; } Comment.cleanJSDocComment = function cleanJSDocComment(content, spacesToRemove) { var docCommentLines = []; content = content.replace("/**", ""); if(content.length >= 2 && content.charAt(content.length - 1) == "/" && content.charAt(content.length - 2) == "*") { content = content.substring(0, content.length - 2); } var lines = content.split("\n"); var inParamTag = false; for(var l = 0; l < lines.length; l++) { var line = lines[l]; var cleanLinePos = Comment.cleanDocCommentLine(line, true, spacesToRemove); if(!cleanLinePos) { continue; } var docCommentText = ""; var prevPos = cleanLinePos.minChar; for(var i = line.indexOf("@", cleanLinePos.minChar); 0 <= i && i < cleanLinePos.limChar; i = line.indexOf("@", i + 1)) { var wasInParamtag = inParamTag; if(line.indexOf("param", i + 1) == i + 1 && Comment.isSpaceChar(line, i + 6)) { if(!wasInParamtag) { docCommentText += line.substring(prevPos, i); } prevPos = i; inParamTag = true; } else { if(wasInParamtag) { prevPos = i; inParamTag = false; } } } if(!inParamTag) { docCommentText += line.substring(prevPos, cleanLinePos.limChar); } var newCleanPos = Comment.cleanDocCommentLine(docCommentText, false); if(newCleanPos) { if(spacesToRemove == undefined) { spacesToRemove = cleanLinePos.jsDocSpacesRemoved; } docCommentLines.push(docCommentText); } } return docCommentLines.join("\n"); } Comment.getDocCommentText = function getDocCommentText(comments) { var docCommentText = []; for(var c = 0; c < comments.length; c++) { var commentText = comments[c].getDocCommentText(); if(commentText != "") { docCommentText.push(commentText); } } return docCommentText.join("\n"); } Comment.getParameterDocCommentText = function getParameterDocCommentText(param, fncDocComments) { if(fncDocComments.length == 0 || !fncDocComments[0].isBlockComment) { return ""; } for(var i = 0; i < fncDocComments.length; i++) { var commentContents = fncDocComments[i].content; for(var j = commentContents.indexOf("@param", 0); 0 <= j; j = commentContents.indexOf("@param", j)) { j += 6; if(!Comment.isSpaceChar(commentContents, j)) { continue; } j = Comment.consumeLeadingSpace(commentContents, j); if(j == -1) { break; } if(commentContents.charCodeAt(j) == TypeScript.LexCodeLC) { j++; var charCode = 0; for(var curlies = 1; j < commentContents.length; j++) { charCode = commentContents.charCodeAt(j); if(charCode == TypeScript.LexCodeLC) { curlies++; continue; } if(charCode == TypeScript.LexCodeRC) { curlies--; if(curlies == 0) { break; } else { continue; } } if(charCode == TypeScript.LexCodeAtSign) { break; } } if(j == commentContents.length) { break; } if(charCode == TypeScript.LexCodeAtSign) { continue; } j = Comment.consumeLeadingSpace(commentContents, j + 1); if(j == -1) { break; } } if(param != commentContents.substr(j, param.length) || !Comment.isSpaceChar(commentContents, j + param.length)) { continue; } j = Comment.consumeLeadingSpace(commentContents, j + param.length); if(j == -1) { return ""; } var endOfParam = commentContents.indexOf("@", j); var paramHelpString = commentContents.substring(j, endOfParam < 0 ? commentContents.length : endOfParam); var paramSpacesToRemove = undefined; var paramLineIndex = commentContents.substring(0, j).lastIndexOf("\n") + 1; if(paramLineIndex != 0) { if(paramLineIndex < j && commentContents.charAt(paramLineIndex + 1) == "\r") { paramLineIndex++; } } var startSpaceRemovalIndex = Comment.consumeLeadingSpace(commentContents, paramLineIndex); if(startSpaceRemovalIndex != j && commentContents.charAt(startSpaceRemovalIndex) == "*") { paramSpacesToRemove = j - startSpaceRemovalIndex - 1; } return Comment.cleanJSDocComment(paramHelpString, paramSpacesToRemove); } } return ""; } Comment.getDocCommentTextOfSignatures = function getDocCommentTextOfSignatures(signatures) { var comments = []; for(var i = 0; i < signatures.length; i++) { var signatureDocComment = TypeScript.Comment.getDocCommentText(signatures[i].declAST.getDocComments()); if(signatureDocComment != "") { comments.push(signatureDocComment); } } return comments.join("\n"); } return Comment; })(AST); TypeScript.Comment = Comment; var DebuggerStatement = (function (_super) { __extends(DebuggerStatement, _super); function DebuggerStatement() { _super.call(this, TypeScript.NodeType.Debugger); } DebuggerStatement.prototype.emit = function (emitter, tokenId, startLine) { emitter.emitParensAndCommentsInPlace(this, true); emitter.recordSourceMappingStart(this); emitter.writeLineToOutput("debugger;"); emitter.recordSourceMappingEnd(this); emitter.emitParensAndCommentsInPlace(this, false); }; return DebuggerStatement; })(Statement); TypeScript.DebuggerStatement = DebuggerStatement; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var AstWalkOptions = (function () { function AstWalkOptions() { this.goChildren = true; this.goNextSibling = true; this.reverseSiblings = false; } AstWalkOptions.prototype.stopWalk = function (stop) { if (typeof stop === "undefined") { stop = true; } this.goChildren = !stop; this.goNextSibling = !stop; }; return AstWalkOptions; })(); TypeScript.AstWalkOptions = AstWalkOptions; var AstWalker = (function () { function AstWalker(childrenWalkers, pre, post, options, state) { this.childrenWalkers = childrenWalkers; this.pre = pre; this.post = post; this.options = options; this.state = state; } AstWalker.prototype.walk = function (ast, parent) { var preAst = this.pre(ast, parent, this); if(preAst === undefined) { preAst = ast; } if(this.options.goChildren) { var svGoSib = this.options.goNextSibling; this.options.goNextSibling = true; this.childrenWalkers[ast.nodeType](ast, parent, this); this.options.goNextSibling = svGoSib; } else { this.options.goChildren = true; } if(this.post) { var postAst = this.post(preAst, parent, this); if(postAst === undefined) { postAst = preAst; } return postAst; } else { return preAst; } }; return AstWalker; })(); var AstWalkerFactory = (function () { function AstWalkerFactory() { this.childrenWalkers = []; this.initChildrenWalkers(); } AstWalkerFactory.prototype.walk = function (ast, pre, post, options, state) { return this.getWalker(pre, post, options, state).walk(ast, null); }; AstWalkerFactory.prototype.getWalker = function (pre, post, options, state) { return this.getSlowWalker(pre, post, options, state); }; AstWalkerFactory.prototype.getSlowWalker = function (pre, post, options, state) { if(!options) { options = new AstWalkOptions(); } return new AstWalker(this.childrenWalkers, pre, post, options, state); }; AstWalkerFactory.prototype.initChildrenWalkers = function () { this.childrenWalkers[TypeScript.NodeType.None] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.Empty] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.EmptyExpr] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.True] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.False] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.This] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.Super] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.QString] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.Regex] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.Null] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.ArrayLit] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.ObjectLit] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Void] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Comma] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Pos] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Neg] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Delete] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Await] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.In] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Dot] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.From] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Is] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.InstOf] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Typeof] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.NumberLit] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.Name] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.TypeRef] = ChildrenWalkers.walkTypeReferenceChildren; this.childrenWalkers[TypeScript.NodeType.Index] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Call] = ChildrenWalkers.walkCallExpressionChildren; this.childrenWalkers[TypeScript.NodeType.New] = ChildrenWalkers.walkCallExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Asg] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgAdd] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgSub] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgDiv] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgMul] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgMod] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgAnd] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgXor] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgOr] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgLsh] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgRsh] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.AsgRs2] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.ConditionalExpression] = ChildrenWalkers.walkTrinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.LogOr] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.LogAnd] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Or] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Xor] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.And] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Eq] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Ne] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Eqv] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.NEqv] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Lt] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Le] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Gt] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Ge] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Add] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Sub] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Mul] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Div] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Mod] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Lsh] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Rsh] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Rs2] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.Not] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.LogNot] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.IncPre] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.DecPre] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.IncPost] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.DecPost] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.TypeAssertion] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.FuncDecl] = ChildrenWalkers.walkFuncDeclChildren; this.childrenWalkers[TypeScript.NodeType.Member] = ChildrenWalkers.walkBinaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.VarDecl] = ChildrenWalkers.walkBoundDeclChildren; this.childrenWalkers[TypeScript.NodeType.ArgDecl] = ChildrenWalkers.walkBoundDeclChildren; this.childrenWalkers[TypeScript.NodeType.Return] = ChildrenWalkers.walkReturnStatementChildren; this.childrenWalkers[TypeScript.NodeType.Break] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.Continue] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.Throw] = ChildrenWalkers.walkUnaryExpressionChildren; this.childrenWalkers[TypeScript.NodeType.For] = ChildrenWalkers.walkForStatementChildren; this.childrenWalkers[TypeScript.NodeType.ForIn] = ChildrenWalkers.walkForInStatementChildren; this.childrenWalkers[TypeScript.NodeType.If] = ChildrenWalkers.walkIfStatementChildren; this.childrenWalkers[TypeScript.NodeType.While] = ChildrenWalkers.walkWhileStatementChildren; this.childrenWalkers[TypeScript.NodeType.DoWhile] = ChildrenWalkers.walkDoWhileStatementChildren; this.childrenWalkers[TypeScript.NodeType.Block] = ChildrenWalkers.walkBlockChildren; this.childrenWalkers[TypeScript.NodeType.Case] = ChildrenWalkers.walkCaseStatementChildren; this.childrenWalkers[TypeScript.NodeType.Switch] = ChildrenWalkers.walkSwitchStatementChildren; this.childrenWalkers[TypeScript.NodeType.Try] = ChildrenWalkers.walkTryChildren; this.childrenWalkers[TypeScript.NodeType.TryCatch] = ChildrenWalkers.walkTryCatchChildren; this.childrenWalkers[TypeScript.NodeType.TryFinally] = ChildrenWalkers.walkTryFinallyChildren; this.childrenWalkers[TypeScript.NodeType.Finally] = ChildrenWalkers.walkFinallyChildren; this.childrenWalkers[TypeScript.NodeType.Catch] = ChildrenWalkers.walkCatchChildren; this.childrenWalkers[TypeScript.NodeType.List] = ChildrenWalkers.walkListChildren; this.childrenWalkers[TypeScript.NodeType.Script] = ChildrenWalkers.walkScriptChildren; this.childrenWalkers[TypeScript.NodeType.ClassDeclaration] = ChildrenWalkers.walkClassDeclChildren; this.childrenWalkers[TypeScript.NodeType.InterfaceDeclaration] = ChildrenWalkers.walkTypeDeclChildren; this.childrenWalkers[TypeScript.NodeType.ModuleDeclaration] = ChildrenWalkers.walkModuleDeclChildren; this.childrenWalkers[TypeScript.NodeType.ImportDeclaration] = ChildrenWalkers.walkImportDeclChildren; this.childrenWalkers[TypeScript.NodeType.With] = ChildrenWalkers.walkWithStatementChildren; this.childrenWalkers[TypeScript.NodeType.Label] = ChildrenWalkers.walkLabelChildren; this.childrenWalkers[TypeScript.NodeType.LabeledStatement] = ChildrenWalkers.walkLabeledStatementChildren; this.childrenWalkers[TypeScript.NodeType.EBStart] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.GotoEB] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.EndCode] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.Error] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.Comment] = ChildrenWalkers.walkNone; this.childrenWalkers[TypeScript.NodeType.Debugger] = ChildrenWalkers.walkNone; for(var e in (TypeScript.NodeType)._map) { if((this.childrenWalkers)[e] === undefined) { throw new Error("initWalkers function is not up to date with enum content!"); } } }; return AstWalkerFactory; })(); TypeScript.AstWalkerFactory = AstWalkerFactory; var globalAstWalkerFactory; function getAstWalkerFactory() { if(!globalAstWalkerFactory) { globalAstWalkerFactory = new AstWalkerFactory(); } return globalAstWalkerFactory; } TypeScript.getAstWalkerFactory = getAstWalkerFactory; var ChildrenWalkers; (function (ChildrenWalkers) { function walkNone(preAst, parent, walker) { } ChildrenWalkers.walkNone = walkNone; function walkListChildren(preAst, parent, walker) { var len = preAst.members.length; if(walker.options.reverseSiblings) { for(var i = len - 1; i >= 0; i--) { if(walker.options.goNextSibling) { preAst.members[i] = walker.walk(preAst.members[i], preAst); } } } else { for(var i = 0; i < len; i++) { if(walker.options.goNextSibling) { preAst.members[i] = walker.walk(preAst.members[i], preAst); } } } } ChildrenWalkers.walkListChildren = walkListChildren; function walkUnaryExpressionChildren(preAst, parent, walker) { if(preAst.castTerm) { preAst.castTerm = walker.walk(preAst.castTerm, preAst); } if(preAst.operand) { preAst.operand = walker.walk(preAst.operand, preAst); } } ChildrenWalkers.walkUnaryExpressionChildren = walkUnaryExpressionChildren; function walkBinaryExpressionChildren(preAst, parent, walker) { if(walker.options.reverseSiblings) { if(preAst.operand2) { preAst.operand2 = walker.walk(preAst.operand2, preAst); } if((preAst.operand1) && (walker.options.goNextSibling)) { preAst.operand1 = walker.walk(preAst.operand1, preAst); } } else { if(preAst.operand1) { preAst.operand1 = walker.walk(preAst.operand1, preAst); } if((preAst.operand2) && (walker.options.goNextSibling)) { preAst.operand2 = walker.walk(preAst.operand2, preAst); } } } ChildrenWalkers.walkBinaryExpressionChildren = walkBinaryExpressionChildren; function walkTypeReferenceChildren(preAst, parent, walker) { if(preAst.term) { preAst.term = walker.walk(preAst.term, preAst); } } ChildrenWalkers.walkTypeReferenceChildren = walkTypeReferenceChildren; function walkCallExpressionChildren(preAst, parent, walker) { if(!walker.options.reverseSiblings) { preAst.target = walker.walk(preAst.target, preAst); } if(preAst.arguments && (walker.options.goNextSibling)) { preAst.arguments = walker.walk(preAst.arguments, preAst); } if((walker.options.reverseSiblings) && (walker.options.goNextSibling)) { preAst.target = walker.walk(preAst.target, preAst); } } ChildrenWalkers.walkCallExpressionChildren = walkCallExpressionChildren; function walkTrinaryExpressionChildren(preAst, parent, walker) { if(preAst.operand1) { preAst.operand1 = walker.walk(preAst.operand1, preAst); } if(preAst.operand2 && (walker.options.goNextSibling)) { preAst.operand2 = walker.walk(preAst.operand2, preAst); } if(preAst.operand3 && (walker.options.goNextSibling)) { preAst.operand3 = walker.walk(preAst.operand3, preAst); } } ChildrenWalkers.walkTrinaryExpressionChildren = walkTrinaryExpressionChildren; function walkFuncDeclChildren(preAst, parent, walker) { if(preAst.name) { preAst.name = walker.walk(preAst.name, preAst); } if(preAst.arguments && (preAst.arguments.members.length > 0) && (walker.options.goNextSibling)) { preAst.arguments = walker.walk(preAst.arguments, preAst); } if(preAst.returnTypeAnnotation && (walker.options.goNextSibling)) { preAst.returnTypeAnnotation = walker.walk(preAst.returnTypeAnnotation, preAst); } if(preAst.bod && (preAst.bod.members.length > 0) && (walker.options.goNextSibling)) { preAst.bod = walker.walk(preAst.bod, preAst); } } ChildrenWalkers.walkFuncDeclChildren = walkFuncDeclChildren; function walkBoundDeclChildren(preAst, parent, walker) { if(preAst.id) { preAst.id = walker.walk(preAst.id, preAst); } if(preAst.init) { preAst.init = walker.walk(preAst.init, preAst); } if((preAst.typeExpr) && (walker.options.goNextSibling)) { preAst.typeExpr = walker.walk(preAst.typeExpr, preAst); } } ChildrenWalkers.walkBoundDeclChildren = walkBoundDeclChildren; function walkReturnStatementChildren(preAst, parent, walker) { if(preAst.returnExpression) { preAst.returnExpression = walker.walk(preAst.returnExpression, preAst); } } ChildrenWalkers.walkReturnStatementChildren = walkReturnStatementChildren; function walkForStatementChildren(preAst, parent, walker) { if(preAst.init) { preAst.init = walker.walk(preAst.init, preAst); } if(preAst.cond && walker.options.goNextSibling) { preAst.cond = walker.walk(preAst.cond, preAst); } if(preAst.incr && walker.options.goNextSibling) { preAst.incr = walker.walk(preAst.incr, preAst); } if(preAst.body && walker.options.goNextSibling) { preAst.body = walker.walk(preAst.body, preAst); } } ChildrenWalkers.walkForStatementChildren = walkForStatementChildren; function walkForInStatementChildren(preAst, parent, walker) { preAst.lval = walker.walk(preAst.lval, preAst); if(walker.options.goNextSibling) { preAst.obj = walker.walk(preAst.obj, preAst); } if(preAst.body && (walker.options.goNextSibling)) { preAst.body = walker.walk(preAst.body, preAst); } } ChildrenWalkers.walkForInStatementChildren = walkForInStatementChildren; function walkIfStatementChildren(preAst, parent, walker) { preAst.cond = walker.walk(preAst.cond, preAst); if(preAst.thenBod && (walker.options.goNextSibling)) { preAst.thenBod = walker.walk(preAst.thenBod, preAst); } if(preAst.elseBod && (walker.options.goNextSibling)) { preAst.elseBod = walker.walk(preAst.elseBod, preAst); } } ChildrenWalkers.walkIfStatementChildren = walkIfStatementChildren; function walkWhileStatementChildren(preAst, parent, walker) { preAst.cond = walker.walk(preAst.cond, preAst); if(preAst.body && (walker.options.goNextSibling)) { preAst.body = walker.walk(preAst.body, preAst); } } ChildrenWalkers.walkWhileStatementChildren = walkWhileStatementChildren; function walkDoWhileStatementChildren(preAst, parent, walker) { preAst.cond = walker.walk(preAst.cond, preAst); if(preAst.body && (walker.options.goNextSibling)) { preAst.body = walker.walk(preAst.body, preAst); } } ChildrenWalkers.walkDoWhileStatementChildren = walkDoWhileStatementChildren; function walkBlockChildren(preAst, parent, walker) { if(preAst.statements) { preAst.statements = walker.walk(preAst.statements, preAst); } } ChildrenWalkers.walkBlockChildren = walkBlockChildren; function walkCaseStatementChildren(preAst, parent, walker) { if(preAst.expr) { preAst.expr = walker.walk(preAst.expr, preAst); } if(preAst.body && walker.options.goNextSibling) { preAst.body = walker.walk(preAst.body, preAst); } } ChildrenWalkers.walkCaseStatementChildren = walkCaseStatementChildren; function walkSwitchStatementChildren(preAst, parent, walker) { if(preAst.val) { preAst.val = walker.walk(preAst.val, preAst); } if((preAst.caseList) && walker.options.goNextSibling) { preAst.caseList = walker.walk(preAst.caseList, preAst); } } ChildrenWalkers.walkSwitchStatementChildren = walkSwitchStatementChildren; function walkTryChildren(preAst, parent, walker) { if(preAst.body) { preAst.body = walker.walk(preAst.body, preAst); } } ChildrenWalkers.walkTryChildren = walkTryChildren; function walkTryCatchChildren(preAst, parent, walker) { if(preAst.tryNode) { preAst.tryNode = walker.walk(preAst.tryNode, preAst); } if((preAst.catchNode) && walker.options.goNextSibling) { preAst.catchNode = walker.walk(preAst.catchNode, preAst); } } ChildrenWalkers.walkTryCatchChildren = walkTryCatchChildren; function walkTryFinallyChildren(preAst, parent, walker) { if(preAst.tryNode) { preAst.tryNode = walker.walk(preAst.tryNode, preAst); } if(preAst.finallyNode && walker.options.goNextSibling) { preAst.finallyNode = walker.walk(preAst.finallyNode, preAst); } } ChildrenWalkers.walkTryFinallyChildren = walkTryFinallyChildren; function walkFinallyChildren(preAst, parent, walker) { if(preAst.body) { preAst.body = walker.walk(preAst.body, preAst); } } ChildrenWalkers.walkFinallyChildren = walkFinallyChildren; function walkCatchChildren(preAst, parent, walker) { if(preAst.param) { preAst.param = walker.walk(preAst.param, preAst); } if((preAst.body) && walker.options.goNextSibling) { preAst.body = walker.walk(preAst.body, preAst); } } ChildrenWalkers.walkCatchChildren = walkCatchChildren; function walkRecordChildren(preAst, parent, walker) { preAst.name = walker.walk(preAst.name, preAst); if(walker.options.goNextSibling && preAst.members) { preAst.members = walker.walk(preAst.members, preAst); } } ChildrenWalkers.walkRecordChildren = walkRecordChildren; function walkNamedTypeChildren(preAst, parent, walker) { walkRecordChildren(preAst, parent, walker); } ChildrenWalkers.walkNamedTypeChildren = walkNamedTypeChildren; function walkClassDeclChildren(preAst, parent, walker) { walkNamedTypeChildren(preAst, parent, walker); if(walker.options.goNextSibling && preAst.extendsList) { preAst.extendsList = walker.walk(preAst.extendsList, preAst); } if(walker.options.goNextSibling && preAst.implementsList) { preAst.implementsList = walker.walk(preAst.implementsList, preAst); } } ChildrenWalkers.walkClassDeclChildren = walkClassDeclChildren; function walkScriptChildren(preAst, parent, walker) { if(preAst.bod) { preAst.bod = walker.walk(preAst.bod, preAst); } } ChildrenWalkers.walkScriptChildren = walkScriptChildren; function walkTypeDeclChildren(preAst, parent, walker) { walkNamedTypeChildren(preAst, parent, walker); if(walker.options.goNextSibling && preAst.extendsList) { preAst.extendsList = walker.walk(preAst.extendsList, preAst); } if(walker.options.goNextSibling && preAst.implementsList) { preAst.implementsList = walker.walk(preAst.implementsList, preAst); } } ChildrenWalkers.walkTypeDeclChildren = walkTypeDeclChildren; function walkModuleDeclChildren(preAst, parent, walker) { walkRecordChildren(preAst, parent, walker); } ChildrenWalkers.walkModuleDeclChildren = walkModuleDeclChildren; function walkImportDeclChildren(preAst, parent, walker) { if(preAst.id) { preAst.id = walker.walk(preAst.id, preAst); } if(preAst.alias) { preAst.alias = walker.walk(preAst.alias, preAst); } } ChildrenWalkers.walkImportDeclChildren = walkImportDeclChildren; function walkWithStatementChildren(preAst, parent, walker) { if(preAst.expr) { preAst.expr = walker.walk(preAst.expr, preAst); } if(preAst.body && walker.options.goNextSibling) { preAst.body = walker.walk(preAst.body, preAst); } } ChildrenWalkers.walkWithStatementChildren = walkWithStatementChildren; function walkLabelChildren(preAst, parent, walker) { } ChildrenWalkers.walkLabelChildren = walkLabelChildren; function walkLabeledStatementChildren(preAst, parent, walker) { preAst.labels = walker.walk(preAst.labels, preAst); if(walker.options.goNextSibling) { preAst.stmt = walker.walk(preAst.stmt, preAst); } } ChildrenWalkers.walkLabeledStatementChildren = walkLabeledStatementChildren; })(ChildrenWalkers || (ChildrenWalkers = {})); })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { (function (AstWalkerWithDetailCallback) { function walk(script, callback) { var pre = function (cur, parent) { walker.options.goChildren = AstWalkerCallback(true, cur, callback); return cur; }; var post = function (cur, parent) { AstWalkerCallback(false, cur, callback); return cur; }; var walker = TypeScript.getAstWalkerFactory().getWalker(pre, post); walker.walk(script, null); } AstWalkerWithDetailCallback.walk = walk; function AstWalkerCallback(pre, ast, callback) { var nodeType = ast.nodeType; var callbackString = (TypeScript.NodeType)._map[nodeType] + "Callback"; if(callback[callbackString]) { return callback[callbackString](pre, ast); } if(callback.DefaultCallback) { return callback.DefaultCallback(pre, ast); } return true; } })(TypeScript.AstWalkerWithDetailCallback || (TypeScript.AstWalkerWithDetailCallback = {})); var AstWalkerWithDetailCallback = TypeScript.AstWalkerWithDetailCallback; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { function lastOf(items) { return (items === null || items.length === 0) ? null : items[items.length - 1]; } TypeScript.lastOf = lastOf; function max(a, b) { return a >= b ? a : b; } TypeScript.max = max; function min(a, b) { return a <= b ? a : b; } TypeScript.min = min; var AstPath = (function () { function AstPath() { this.asts = []; this.top = -1; } AstPath.reverseIndexOf = function reverseIndexOf(items, index) { return (items === null || items.length <= index) ? null : items[items.length - index - 1]; } AstPath.prototype.clone = function () { var clone = new AstPath(); clone.asts = this.asts.map(function (value) { return value; }); clone.top = this.top; return clone; }; AstPath.prototype.pop = function () { var head = this.ast(); this.up(); while(this.asts.length > this.count()) { this.asts.pop(); } return head; }; AstPath.prototype.push = function (ast) { while(this.asts.length > this.count()) { this.asts.pop(); } this.top = this.asts.length; this.asts.push(ast); }; AstPath.prototype.up = function () { if(this.top <= -1) { throw new Error("Invalid call to 'up'"); } this.top--; }; AstPath.prototype.down = function () { if(this.top == this.ast.length - 1) { throw new Error("Invalid call to 'down'"); } this.top++; }; AstPath.prototype.nodeType = function () { if(this.ast() == null) { return TypeScript.NodeType.None; } return this.ast().nodeType; }; AstPath.prototype.ast = function () { return AstPath.reverseIndexOf(this.asts, this.asts.length - (this.top + 1)); }; AstPath.prototype.parent = function () { return AstPath.reverseIndexOf(this.asts, this.asts.length - this.top); }; AstPath.prototype.count = function () { return this.top + 1; }; AstPath.prototype.get = function (index) { return this.asts[index]; }; AstPath.prototype.isNameOfClass = function () { if(this.ast() === null || this.parent() === null) { return false; } return (this.ast().nodeType === TypeScript.NodeType.Name) && (this.parent().nodeType === TypeScript.NodeType.ClassDeclaration) && ((this.parent()).name === this.ast()); }; AstPath.prototype.isNameOfInterface = function () { if(this.ast() === null || this.parent() === null) { return false; } return (this.ast().nodeType === TypeScript.NodeType.Name) && (this.parent().nodeType === TypeScript.NodeType.InterfaceDeclaration) && ((this.parent()).name === this.ast()); }; AstPath.prototype.isNameOfArgument = function () { if(this.ast() === null || this.parent() === null) { return false; } return (this.ast().nodeType === TypeScript.NodeType.Name) && (this.parent().nodeType === TypeScript.NodeType.ArgDecl) && ((this.parent()).id === this.ast()); }; AstPath.prototype.isNameOfVariable = function () { if(this.ast() === null || this.parent() === null) { return false; } return (this.ast().nodeType === TypeScript.NodeType.Name) && (this.parent().nodeType === TypeScript.NodeType.VarDecl) && ((this.parent()).id === this.ast()); }; AstPath.prototype.isNameOfModule = function () { if(this.ast() === null || this.parent() === null) { return false; } return (this.ast().nodeType === TypeScript.NodeType.Name) && (this.parent().nodeType === TypeScript.NodeType.ModuleDeclaration) && ((this.parent()).name === this.ast()); }; AstPath.prototype.isNameOfFunction = function () { if(this.ast() === null || this.parent() === null) { return false; } return (this.ast().nodeType === TypeScript.NodeType.Name) && (this.parent().nodeType === TypeScript.NodeType.FuncDecl) && ((this.parent()).name === this.ast()); }; AstPath.prototype.isChildOfScript = function () { var ast = lastOf(this.asts); return this.count() >= 3 && this.asts[this.top] === ast && this.asts[this.top - 1].nodeType === TypeScript.NodeType.List && this.asts[this.top - 2].nodeType === TypeScript.NodeType.Script; }; AstPath.prototype.isChildOfModule = function () { var ast = lastOf(this.asts); return this.count() >= 3 && this.asts[this.top] === ast && this.asts[this.top - 1].nodeType === TypeScript.NodeType.List && this.asts[this.top - 2].nodeType === TypeScript.NodeType.ModuleDeclaration; }; AstPath.prototype.isChildOfClass = function () { var ast = lastOf(this.asts); return this.count() >= 3 && this.asts[this.top] === ast && this.asts[this.top - 1].nodeType === TypeScript.NodeType.List && this.asts[this.top - 2].nodeType === TypeScript.NodeType.ClassDeclaration; }; AstPath.prototype.isArgumentOfClassConstructor = function () { var ast = lastOf(this.asts); return this.count() >= 5 && this.asts[this.top] === ast && this.asts[this.top - 1].nodeType === TypeScript.NodeType.List && this.asts[this.top - 2].nodeType === TypeScript.NodeType.FuncDecl && this.asts[this.top - 3].nodeType === TypeScript.NodeType.List && this.asts[this.top - 4].nodeType === TypeScript.NodeType.ClassDeclaration && ((this.asts[this.top - 2]).isConstructor) && ((this.asts[this.top - 2]).arguments === this.asts[this.top - 1]) && ((this.asts[this.top - 4]).constructorDecl === this.asts[this.top - 2]); }; AstPath.prototype.isChildOfInterface = function () { var ast = lastOf(this.asts); return this.count() >= 3 && this.asts[this.top] === ast && this.asts[this.top - 1].nodeType === TypeScript.NodeType.List && this.asts[this.top - 2].nodeType === TypeScript.NodeType.InterfaceDeclaration; }; AstPath.prototype.isTopLevelImplicitModule = function () { return this.count() >= 1 && this.asts[this.top].nodeType === TypeScript.NodeType.ModuleDeclaration && TypeScript.hasFlag((this.asts[this.top]).modFlags, TypeScript.ModuleFlags.IsWholeFile); }; AstPath.prototype.isBodyOfTopLevelImplicitModule = function () { return this.count() >= 2 && this.asts[this.top - 0].nodeType === TypeScript.NodeType.List && this.asts[this.top - 1].nodeType === TypeScript.NodeType.ModuleDeclaration && (this.asts[this.top - 1]).members == this.asts[this.top - 0] && TypeScript.hasFlag((this.asts[this.top - 1]).modFlags, TypeScript.ModuleFlags.IsWholeFile); }; AstPath.prototype.isBodyOfScript = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Script && (this.asts[this.top - 1]).bod == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfSwitch = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Switch && (this.asts[this.top - 1]).caseList == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfModule = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.ModuleDeclaration && (this.asts[this.top - 1]).members == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfClass = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.ClassDeclaration && (this.asts[this.top - 1]).members == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfFunction = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.FuncDecl && (this.asts[this.top - 1]).bod == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfInterface = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.InterfaceDeclaration && (this.asts[this.top - 1]).members == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfBlock = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Block && (this.asts[this.top - 1]).statements == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfFor = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.For && (this.asts[this.top - 1]).body == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfCase = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Case && (this.asts[this.top - 1]).body == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfTry = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Try && (this.asts[this.top - 1]).body == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfCatch = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Catch && (this.asts[this.top - 1]).body == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfDoWhile = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.DoWhile && (this.asts[this.top - 1]).body == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfWhile = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.While && (this.asts[this.top - 1]).body == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfForIn = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.ForIn && (this.asts[this.top - 1]).body == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfWith = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.With && (this.asts[this.top - 1]).body == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfFinally = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Finally && (this.asts[this.top - 1]).body == this.asts[this.top - 0]; }; AstPath.prototype.isCaseOfSwitch = function () { return this.count() >= 3 && this.asts[this.top - 2].nodeType === TypeScript.NodeType.Switch && this.asts[this.top - 1].nodeType === TypeScript.NodeType.List && (this.asts[this.top - 2]).caseList == this.asts[this.top - 1]; }; AstPath.prototype.isDefaultCaseOfSwitch = function () { return this.count() >= 3 && this.asts[this.top - 2].nodeType === TypeScript.NodeType.Switch && this.asts[this.top - 1].nodeType === TypeScript.NodeType.List && (this.asts[this.top - 2]).caseList == this.asts[this.top - 1] && (this.asts[this.top - 2]).defaultCase == this.asts[this.top - 0]; }; AstPath.prototype.isListOfObjectLit = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.ObjectLit && this.asts[this.top - 0].nodeType === TypeScript.NodeType.List && (this.asts[this.top - 1]).operand == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfObjectLit = function () { return this.isListOfObjectLit(); }; AstPath.prototype.isEmptyListOfObjectLit = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.ObjectLit && this.asts[this.top - 0].nodeType === TypeScript.NodeType.List && (this.asts[this.top - 1]).operand == this.asts[this.top - 0] && (this.asts[this.top - 0]).members.length == 0; }; AstPath.prototype.isMemberOfObjectLit = function () { return this.count() >= 3 && this.asts[this.top - 2].nodeType === TypeScript.NodeType.ObjectLit && this.asts[this.top - 1].nodeType === TypeScript.NodeType.List && this.asts[this.top - 0].nodeType === TypeScript.NodeType.Member && (this.asts[this.top - 2]).operand == this.asts[this.top - 1]; }; AstPath.prototype.isNameOfMemberOfObjectLit = function () { return this.count() >= 4 && this.asts[this.top - 3].nodeType === TypeScript.NodeType.ObjectLit && this.asts[this.top - 2].nodeType === TypeScript.NodeType.List && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Member && this.asts[this.top - 0].nodeType === TypeScript.NodeType.Name && (this.asts[this.top - 3]).operand == this.asts[this.top - 2]; }; AstPath.prototype.isListOfArrayLit = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.ArrayLit && this.asts[this.top - 0].nodeType === TypeScript.NodeType.List && (this.asts[this.top - 1]).operand == this.asts[this.top - 0]; }; AstPath.prototype.isTargetOfMember = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Member && (this.asts[this.top - 1]).operand1 === this.asts[this.top - 0]; }; AstPath.prototype.isMemberOfMember = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Member && (this.asts[this.top - 1]).operand2 === this.asts[this.top - 0]; }; AstPath.prototype.isItemOfList = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.List; }; AstPath.prototype.isThenOfIf = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.If && (this.asts[this.top - 1]).thenBod == this.asts[this.top - 0]; }; AstPath.prototype.isElseOfIf = function () { return this.count() >= 2 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.If && (this.asts[this.top - 1]).elseBod == this.asts[this.top - 0]; }; AstPath.prototype.isBodyOfDefaultCase = function () { return this.isBodyOfCase(); }; AstPath.prototype.isSingleStatementList = function () { return this.count() >= 1 && this.asts[this.top].nodeType === TypeScript.NodeType.List && (this.asts[this.top]).members.length === 1; }; AstPath.prototype.isArgumentListOfFunction = function () { return this.count() >= 2 && this.asts[this.top - 0].nodeType === TypeScript.NodeType.List && this.asts[this.top - 1].nodeType === TypeScript.NodeType.FuncDecl && (this.asts[this.top - 1]).arguments === this.asts[this.top - 0]; }; AstPath.prototype.isArgumentOfFunction = function () { return this.count() >= 3 && this.asts[this.top - 1].nodeType === TypeScript.NodeType.List && this.asts[this.top - 2].nodeType === TypeScript.NodeType.FuncDecl && (this.asts[this.top - 2]).arguments === this.asts[this.top - 1]; }; AstPath.prototype.isArgumentListOfCall = function () { return this.count() >= 2 && this.asts[this.top - 0].nodeType === TypeScript.NodeType.List && this.asts[this.top - 1].nodeType === TypeScript.NodeType.Call && (this.asts[this.top - 1]).arguments === this.asts[this.top - 0]; }; AstPath.prototype.isArgumentListOfNew = function () { return this.count() >= 2 && this.asts[this.top - 0].nodeType === TypeScript.NodeType.List && this.asts[this.top - 1].nodeType === TypeScript.NodeType.New && (this.asts[this.top - 1]).arguments === this.asts[this.top - 0]; }; AstPath.prototype.isSynthesizedBlock = function () { return this.count() >= 1 && this.asts[this.top - 0].nodeType === TypeScript.NodeType.Block && (this.asts[this.top - 0]).isStatementBlock === false; }; return AstPath; })(); TypeScript.AstPath = AstPath; function isValidAstNode(ast) { if(ast === null) { return false; } if(ast.minChar === -1 || ast.limChar === -1) { return false; } return true; } TypeScript.isValidAstNode = isValidAstNode; var AstPathContext = (function () { function AstPathContext() { this.path = new TypeScript.AstPath(); } return AstPathContext; })(); TypeScript.AstPathContext = AstPathContext; (function (GetAstPathOptions) { GetAstPathOptions._map = []; GetAstPathOptions.Default = 0; GetAstPathOptions.EdgeInclusive = 1; GetAstPathOptions.DontPruneSearchBasedOnPosition = 1 << 1; })(TypeScript.GetAstPathOptions || (TypeScript.GetAstPathOptions = {})); var GetAstPathOptions = TypeScript.GetAstPathOptions; function getAstPathToPosition(script, pos, options) { if (typeof options === "undefined") { options = GetAstPathOptions.Default; } var lookInComments = function (comments) { if(comments && comments.length > 0) { for(var i = 0; i < comments.length; i++) { var minChar = comments[i].minChar; var limChar = comments[i].limChar; if(!comments[i].isBlockComment) { limChar++; } if(pos >= minChar && pos < limChar) { ctx.path.push(comments[i]); } } } }; var pre = function (cur, parent, walker) { if(isValidAstNode(cur)) { var inclusive = TypeScript.hasFlag(options, GetAstPathOptions.EdgeInclusive) || cur.nodeType === TypeScript.NodeType.Name || pos === script.limChar; var minChar = cur.minChar; var limChar = cur.limChar + (inclusive ? 1 : 0); if(pos >= minChar && pos < limChar) { var previous = ctx.path.ast(); if(previous == null || (cur.minChar >= previous.minChar && cur.limChar <= previous.limChar)) { ctx.path.push(cur); } else { } } if(pos < limChar) { lookInComments(cur.preComments); } if(pos >= minChar) { lookInComments(cur.postComments); } if(!TypeScript.hasFlag(options, GetAstPathOptions.DontPruneSearchBasedOnPosition)) { walker.options.goChildren = (minChar <= pos && pos <= limChar); } } return cur; }; var ctx = new AstPathContext(); TypeScript.getAstWalkerFactory().walk(script, pre, null, null, ctx); return ctx.path; } TypeScript.getAstPathToPosition = getAstPathToPosition; function getTokenizationOffset(script, position) { var bestOffset = 0; var pre = function (cur, parent, walker) { if(TypeScript.isValidAstNode(cur)) { if(cur.minChar <= position) { bestOffset = max(bestOffset, cur.minChar); } if(cur.minChar > position || cur.limChar < bestOffset) { walker.options.goChildren = false; } } return cur; }; TypeScript.getAstWalkerFactory().walk(script, pre); return bestOffset; } TypeScript.getTokenizationOffset = getTokenizationOffset; function walkAST(ast, callback) { var pre = function (cur, parent, walker) { var path = walker.state; path.push(cur); callback(path, walker); return cur; }; var post = function (cur, parent, walker) { var path = walker.state; path.pop(); return cur; }; var path = new AstPath(); TypeScript.getAstWalkerFactory().walk(ast, pre, post, null, path); } TypeScript.walkAST = walkAST; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var AstLogger = (function () { function AstLogger(logger) { this.logger = logger; } AstLogger.prototype.logScript = function (script) { var _this = this; this.logLinemap(script.locationInfo.lineMap); var stack = []; var pre = function (cur, parent) { stack.push(cur); var indent = (stack.length - 1) * 2; _this.logComments(script, cur.preComments, indent); _this.logNode(script, cur, indent); _this.logComments(script, cur.postComments, indent); return cur; }; var post = function (cur, parent) { stack.pop(); return cur; }; TypeScript.getAstWalkerFactory().walk(script, pre, post); }; AstLogger.prototype.logNode = function (script, cur, indent) { var msg = this.addPadding("", indent, "| ", true); msg = msg.concat("+ " + cur.treeViewLabel()); msg = this.addPadding(msg, 70, " ", false); msg = msg + this.addLineColumn(script, cur.minChar); msg = this.addPadding(msg, 80, " ", false); msg = msg + "=> "; msg = msg + this.addLineColumn(script, cur.limChar); msg = this.addPadding(msg, 102, " ", false); msg = msg.concat("[" + this.addPadding(cur.minChar.toString(), 1, " ", true) + ", " + this.addPadding(cur.limChar.toString(), 1, " ", true) + "]"); msg = this.addPadding(msg, 115, " ", false); msg = msg.concat("sym=" + (cur).sym); msg = this.addPadding(msg, 135, " ", false); msg = msg.concat("type=" + (cur.type === null ? "null" : cur.type.getTypeName())); this.logger.log(msg); }; AstLogger.prototype.logComments = function (script, comments, indent) { if(comments == null) { return; } for(var i = 0; i < comments.length; i++) { this.logNode(script, comments[i], indent); } }; AstLogger.prototype.logLinemap = function (linemap) { var result = "["; for(var i = 0; i < linemap.length; i++) { if(i > 0) { result += ","; } result += linemap[i]; } result += "]"; this.logger.log("linemap: " + result); }; AstLogger.prototype.addPadding = function (s, targetLength, paddingString, leftPadding) { var result = (leftPadding ? "" : s); for(var i = s.length; i < targetLength; i++) { result = result + paddingString; } result = result + (leftPadding ? s : ""); return result; }; AstLogger.prototype.addLineColumn = function (script, position) { var lineInfo = { line: -1, col: -1 }; TypeScript.getSourceLineColFromMap(lineInfo, position, script.locationInfo.lineMap); if(lineInfo.col !== -1) { lineInfo.col++; } return "(" + lineInfo.line + ", " + lineInfo.col + ")"; }; return AstLogger; })(); TypeScript.AstLogger = AstLogger; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var Binder = (function () { function Binder(checker) { this.checker = checker; } Binder.prototype.resolveBaseTypeLinks = function (typeLinks, scope) { var extendsList = null; if(typeLinks) { extendsList = new Array(); for(var i = 0, len = typeLinks.length; i < len; i++) { extendsList[i] = this.checker.resolveBaseTypeLink(typeLinks[i], scope); } } return extendsList; }; Binder.prototype.resolveBases = function (scope, type) { type.extendsList = this.resolveBaseTypeLinks(type.extendsTypeLinks, scope); var i = 0, len = type.extendsList.length; var derivedIsClass = type.isClassInstance(); for(; i < len; i++) { var baseIsClass = type.extendsList[i].isClassInstance(); if(type.extendsList[i] != this.checker.anyType) { var baseRef = type.extendsTypeLinks[i].ast; if(derivedIsClass) { if(!baseIsClass) { this.checker.errorReporter.simpleError(baseRef, "A class may only extend other classes, " + type.extendsList[i].symbol.fullName() + " is not a class."); } } else { if(baseIsClass) { this.checker.errorReporter.simpleError(baseRef, "An interface may only extend other interfaces, " + type.extendsList[i].symbol.fullName() + " is a class."); } } } } type.implementsList = this.resolveBaseTypeLinks(type.implementsTypeLinks, scope); if(type.implementsList) { for(i = 0 , len = type.implementsList.length; i < len; i++) { var iface = type.implementsList[i]; var baseRef = type.implementsTypeLinks[i].ast; if(iface.isClassInstance()) { if(derivedIsClass) { this.checker.errorReporter.simpleError(baseRef, "A class may only implement an interface; " + iface.symbol.fullName() + " is a class."); } } } } }; Binder.prototype.resolveSignatureGroup = function (signatureGroup, scope, instanceType) { var supplyVar = !(signatureGroup.hasImplementation); for(var i = 0, len = signatureGroup.signatures.length; i < len; i++) { var signature = signatureGroup.signatures[i]; if(instanceType) { signature.returnType.type = instanceType; } else { this.checker.resolveTypeLink(scope, signature.returnType, supplyVar); } var paramLen = signature.parameters.length; for(var j = 0; j < paramLen; j++) { this.bindSymbol(scope, signature.parameters[j]); } if(signature.hasVariableArgList) { var lastParam = signature.parameters[paramLen - 1]; lastParam.argsOffset = paramLen - 1; if(!lastParam.getType().isArray()) { this.checker.errorReporter.simpleErrorFromSym(lastParam, "... parameter must have array type"); lastParam.parameter.typeLink.type = this.checker.makeArrayType(lastParam.parameter.typeLink.type); } } } }; Binder.prototype.bindType = function (scope, type, instanceType) { if(instanceType) { this.bindType(scope, instanceType, null); } if(type.hasMembers()) { var members = type.members; var ambientMembers = type.ambientMembers; var typeMembers = type.getAllEnclosedTypes(); var ambientTypeMembers = type.getAllAmbientEnclosedTypes(); var memberScope = new TypeScript.SymbolTableScope(members, ambientMembers, typeMembers, ambientTypeMembers, type.symbol); var agg = new TypeScript.SymbolAggregateScope(type.symbol); var prevCurrentModDecl = this.checker.currentModDecl; var prevBindStatus = this.checker.inBind; agg.addParentScope(memberScope); agg.addParentScope(scope); if(type.isModuleType()) { this.checker.currentModDecl = type.symbol.declAST; this.checker.inBind = true; } if(members) { this.bind(agg, type.members.allMembers); } if(typeMembers) { this.bind(agg, typeMembers.allMembers); } if(ambientMembers) { this.bind(agg, ambientMembers.allMembers); } if(ambientTypeMembers) { this.bind(agg, ambientTypeMembers.allMembers); } this.checker.currentModDecl = prevCurrentModDecl; this.checker.inBind = prevBindStatus; } if(type.extendsTypeLinks) { this.resolveBases(scope, type); } if(type.construct) { this.resolveSignatureGroup(type.construct, scope, instanceType); } if(type.call) { this.resolveSignatureGroup(type.call, scope, null); } if(type.index) { this.resolveSignatureGroup(type.index, scope, null); } if(type.elementType) { this.bindType(scope, type.elementType, null); } }; Binder.prototype.bindSymbol = function (scope, symbol) { if(!symbol.bound) { var prevLocationInfo = this.checker.locationInfo; if((this.checker.units) && (symbol.unitIndex >= 0) && (symbol.unitIndex < this.checker.units.length)) { this.checker.locationInfo = this.checker.units[symbol.unitIndex]; } switch(symbol.kind()) { case TypeScript.SymbolKind.Type: { if(symbol.flags & TypeScript.SymbolFlags.Bound) { break; } var typeSymbol = symbol; typeSymbol.flags |= TypeScript.SymbolFlags.Bound; if(typeSymbol.aliasLink && !typeSymbol.type && typeSymbol.aliasLink.alias.nodeType == TypeScript.NodeType.Name) { var modPath = (typeSymbol.aliasLink.alias).text; var modSym = this.checker.findSymbolForDynamicModule(modPath, this.checker.locationInfo.filename, function (id) { return scope.find(id, false, true); }); if(modSym) { typeSymbol.type = modSym.getType(); } } if(typeSymbol.type && typeSymbol.type != this.checker.gloModType) { this.bindType(scope, typeSymbol.type, typeSymbol.instanceType); if(typeSymbol.type.isModuleType()) { for(var i = 0; i < typeSymbol.expansions.length; i++) { this.bindType(scope, typeSymbol.expansions[i], typeSymbol.instanceType); } } } break; } case TypeScript.SymbolKind.Field: { this.checker.resolveTypeLink(scope, (symbol).field.typeLink, false); break; } case TypeScript.SymbolKind.Parameter: { this.checker.resolveTypeLink(scope, (symbol).parameter.typeLink, true); break; } } this.checker.locationInfo = prevLocationInfo; } symbol.bound = true; }; Binder.prototype.bind = function (scope, table) { table.map(function (key, sym, binder) { binder.bindSymbol(scope, sym); }, this); }; return Binder; })(); TypeScript.Binder = Binder; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var Base64Format = (function () { function Base64Format() { } Base64Format.encodedValues = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; Base64Format.encode = function encode(inValue) { if(inValue < 64) { return Base64Format.encodedValues.charAt(inValue); } throw TypeError(inValue + ": not a 64 based value"); } Base64Format.decodeChar = function decodeChar(inChar) { if(inChar.length === 1) { return Base64Format.encodedValues.indexOf(inChar); } else { throw TypeError('"' + inChar + '" must have length 1'); } } return Base64Format; })(); var Base64VLQFormat = (function () { function Base64VLQFormat() { } Base64VLQFormat.encode = function encode(inValue) { if(inValue < 0) { inValue = ((-inValue) << 1) + 1; } else { inValue = inValue << 1; } var encodedStr = ""; do { var currentDigit = inValue & 31; inValue = inValue >> 5; if(inValue > 0) { currentDigit = currentDigit | 32; } encodedStr = encodedStr + Base64Format.encode(currentDigit); }while(inValue > 0) return encodedStr; } Base64VLQFormat.decode = function decode(inString) { var result = 0; var negative = false; var shift = 0; for(var i = 0; i < inString.length; i++) { var byte = Base64Format.decodeChar(inString[i]); if(i === 0) { if((byte & 1) === 1) { negative = true; } result = (byte >> 1) & 15; } else { result = result | ((byte & 31) << shift); } shift += (i == 0) ? 4 : 5; if((byte & 32) === 32) { } else { return { value: negative ? -(result) : result, rest: inString.substr(i + 1) }; } } throw new Error('Base64 value "' + inString + '" finished with a continuation bit'); } return Base64VLQFormat; })(); TypeScript.Base64VLQFormat = Base64VLQFormat; })(TypeScript || (TypeScript = {})); var JSON2 = { }; ((function () { 'use strict'; function f(n) { return n < 10 ? '0' + n : n; } if(typeof Date.prototype.toJSON !== 'function') { Date.prototype.toJSON = function (key) { return isFinite(this.valueOf()) ? this.getUTCFullYear() + '-' + f(this.getUTCMonth() + 1) + '-' + f(this.getUTCDate()) + 'T' + f(this.getUTCHours()) + ':' + f(this.getUTCMinutes()) + ':' + f(this.getUTCSeconds()) + 'Z' : null; }; var strProto = String.prototype; var numProto = Number.prototype; numProto.JSON = strProto.JSON = (Boolean).prototype.toJSON = function (key) { return this.valueOf(); }; } var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, gap, indent, meta = { '\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '"': '\\"', '\\': '\\\\' }, rep; function quote(string) { escapable.lastIndex = 0; return escapable.test(string) ? '"' + string.replace(escapable, function (a) { var c = meta[a]; return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); }) + '"' : '"' + string + '"'; } function str(key, holder) { var i, k = null, v, length, mind = gap, partial, value = holder[key]; if(value && typeof value === 'object' && typeof value.toJSON === 'function') { value = value.toJSON(key); } if(typeof rep === 'function') { value = rep.call(holder, key, value); } switch(typeof value) { case 'string': { return quote(value); } case 'number': { return isFinite(value) ? String(value) : 'null'; } case 'boolean': case 'null': { return String(value); } case 'object': { if(!value) { return 'null'; } gap += indent; partial = []; if(Object.prototype.toString.apply(value, []) === '[object Array]') { length = value.length; for(i = 0; i < length; i += 1) { partial[i] = str(i, value) || 'null'; } v = partial.length === 0 ? '[]' : gap ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' : '[' + partial.join(',') + ']'; gap = mind; return v; } if(rep && typeof rep === 'object') { length = rep.length; for(i = 0; i < length; i += 1) { if(typeof rep[i] === 'string') { k = rep[i]; v = str(k, value); if(v) { partial.push(quote(k) + (gap ? ': ' : ':') + v); } } } } else { for(k in value) { if(Object.prototype.hasOwnProperty.call(value, k)) { v = str(k, value); if(v) { partial.push(quote(k) + (gap ? ': ' : ':') + v); } } } } v = partial.length === 0 ? '{}' : gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' : '{' + partial.join(',') + '}'; gap = mind; return v; } } } if(typeof JSON2.stringify !== 'function') { JSON2.stringify = function (value, replacer, space) { var i; gap = ''; indent = ''; if(typeof space === 'number') { for(i = 0; i < space; i += 1) { indent += ' '; } } else { if(typeof space === 'string') { indent = space; } } rep = replacer; if(replacer && typeof replacer !== 'function' && (typeof replacer !== 'object' || typeof replacer.length !== 'number')) { throw new Error('JSON.stringify'); } return str('', { '': value }); }; } if(typeof JSON2.parse !== 'function') { JSON2.parse = function (text, reviver) { var j; function walk(holder, key) { var k = null, v, value = holder[key]; if(value && typeof value === 'object') { for(k in value) { if(Object.prototype.hasOwnProperty.call(value, k)) { v = walk(value, k); if(v !== undefined) { value[k] = v; } else { delete value[k]; } } } } return reviver.call(holder, key, value); } text = String(text); cx.lastIndex = 0; if(cx.test(text)) { text = text.replace(cx, function (a) { return '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); }); } if(/^[\],:{}\s]*$/.test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) { j = eval('(' + text + ')'); return typeof reviver === 'function' ? walk({ '': j }, '') : j; } throw new SyntaxError('JSON.parse'); }; } })()); var TypeScript; (function (TypeScript) { var SourceMapPosition = (function () { function SourceMapPosition() { } return SourceMapPosition; })(); TypeScript.SourceMapPosition = SourceMapPosition; var SourceMapping = (function () { function SourceMapping() { this.start = new SourceMapPosition(); this.end = new SourceMapPosition(); this.nameIndex = -1; this.childMappings = []; } return SourceMapping; })(); TypeScript.SourceMapping = SourceMapping; var SourceMapper = (function () { function SourceMapper(tsFileName, jsFileName, jsFile, sourceMapOut, errorReporter) { this.jsFile = jsFile; this.sourceMapOut = sourceMapOut; this.errorReporter = errorReporter; this.sourceMappings = []; this.currentMappings = []; this.names = []; this.currentNameIndex = []; this.currentMappings.push(this.sourceMappings); jsFileName = TypeScript.switchToForwardSlashes(jsFileName); this.jsFileName = TypeScript.getPrettyName(jsFileName, false, true); var removalIndex = jsFileName.lastIndexOf(this.jsFileName); var fixedPath = jsFileName.substring(0, removalIndex); this.tsFileName = TypeScript.getRelativePathToFixedPath(fixedPath, tsFileName); } SourceMapper.MapFileExtension = ".map"; SourceMapper.EmitSourceMapping = function EmitSourceMapping(allSourceMappers) { var sourceMapper = allSourceMappers[0]; sourceMapper.jsFile.WriteLine("//@ sourceMappingURL=" + sourceMapper.jsFileName + SourceMapper.MapFileExtension); var sourceMapOut = sourceMapper.sourceMapOut; var mappingsString = ""; var tsFiles = []; var prevEmittedColumn = 0; var prevEmittedLine = 0; var prevSourceColumn = 0; var prevSourceLine = 0; var prevSourceIndex = 0; var prevNameIndex = 0; var namesList = []; var namesCount = 0; var emitComma = false; var recordedPosition = null; for(var sourceMapperIndex = 0; sourceMapperIndex < allSourceMappers.length; sourceMapperIndex++) { sourceMapper = allSourceMappers[sourceMapperIndex]; var currentSourceIndex = tsFiles.length; tsFiles.push(sourceMapper.tsFileName); if(sourceMapper.names.length > 0) { namesList.push.apply(namesList, sourceMapper.names); } var recordSourceMapping = function (mappedPosition, nameIndex) { if(recordedPosition != null && recordedPosition.emittedColumn == mappedPosition.emittedColumn && recordedPosition.emittedLine == mappedPosition.emittedLine) { return; } if(prevEmittedLine !== mappedPosition.emittedLine) { while(prevEmittedLine < mappedPosition.emittedLine) { prevEmittedColumn = 0; mappingsString = mappingsString + ";"; prevEmittedLine++; } emitComma = false; } else { if(emitComma) { mappingsString = mappingsString + ","; } } mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.emittedColumn - prevEmittedColumn); prevEmittedColumn = mappedPosition.emittedColumn; mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(currentSourceIndex - prevSourceIndex); prevSourceIndex = currentSourceIndex; mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.sourceLine - 1 - prevSourceLine); prevSourceLine = mappedPosition.sourceLine - 1; mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.sourceColumn - prevSourceColumn); prevSourceColumn = mappedPosition.sourceColumn; if(nameIndex >= 0) { mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(namesCount + nameIndex - prevNameIndex); prevNameIndex = namesCount + nameIndex; } emitComma = true; recordedPosition = mappedPosition; }; var recordSourceMappingSiblings = function (sourceMappings) { for(var i = 0; i < sourceMappings.length; i++) { var sourceMapping = sourceMappings[i]; recordSourceMapping(sourceMapping.start, sourceMapping.nameIndex); recordSourceMappingSiblings(sourceMapping.childMappings); recordSourceMapping(sourceMapping.end, sourceMapping.nameIndex); } }; recordSourceMappingSiblings(sourceMapper.sourceMappings, -1); namesCount = namesCount + sourceMapper.names.length; } if(mappingsString != "") { sourceMapOut.Write(JSON2.stringify({ version: 3, file: sourceMapper.jsFileName, sources: tsFiles, names: namesList, mappings: mappingsString })); } try { sourceMapOut.Close(); } catch (ex) { sourceMapper.errorReporter.emitterError(null, ex.message); } } return SourceMapper; })(); TypeScript.SourceMapper = SourceMapper; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { (function (EmitContainer) { EmitContainer._map = []; EmitContainer._map[0] = "Prog"; EmitContainer.Prog = 0; EmitContainer._map[1] = "Module"; EmitContainer.Module = 1; EmitContainer._map[2] = "DynamicModule"; EmitContainer.DynamicModule = 2; EmitContainer._map[3] = "Class"; EmitContainer.Class = 3; EmitContainer._map[4] = "Constructor"; EmitContainer.Constructor = 4; EmitContainer._map[5] = "Function"; EmitContainer.Function = 5; EmitContainer._map[6] = "Args"; EmitContainer.Args = 6; EmitContainer._map[7] = "Interface"; EmitContainer.Interface = 7; })(TypeScript.EmitContainer || (TypeScript.EmitContainer = {})); var EmitContainer = TypeScript.EmitContainer; var EmitState = (function () { function EmitState() { this.column = 0; this.line = 0; this.pretty = false; this.inObjectLiteral = false; this.container = EmitContainer.Prog; } return EmitState; })(); TypeScript.EmitState = EmitState; var EmitOptions = (function () { function EmitOptions(settings) { this.ioHost = null; this.outputMany = true; this.commonDirectoryPath = ""; this.minWhitespace = settings.minWhitespace; this.propagateConstants = settings.propagateConstants; this.emitComments = settings.emitComments; this.outputOption = settings.outputOption; } EmitOptions.prototype.mapOutputFileName = function (fileName, extensionChanger) { if(this.outputMany) { var updatedFileName = fileName; if(this.outputOption != "") { updatedFileName = fileName.replace(this.commonDirectoryPath, ""); updatedFileName = this.outputOption + updatedFileName; } return extensionChanger(updatedFileName, false); } else { return extensionChanger(this.outputOption, true); } }; return EmitOptions; })(); TypeScript.EmitOptions = EmitOptions; var Indenter = (function () { function Indenter() { this.indentAmt = 0; } Indenter.indentStep = 4; Indenter.indentStepString = " "; Indenter.indentStrings = []; Indenter.prototype.increaseIndent = function () { this.indentAmt += Indenter.indentStep; }; Indenter.prototype.decreaseIndent = function () { this.indentAmt -= Indenter.indentStep; }; Indenter.prototype.getIndent = function () { var indentString = Indenter.indentStrings[this.indentAmt]; if(indentString === undefined) { indentString = ""; for(var i = 0; i < this.indentAmt; i = i + Indenter.indentStep) { indentString += Indenter.indentStepString; } Indenter.indentStrings[this.indentAmt] = indentString; } return indentString; }; return Indenter; })(); TypeScript.Indenter = Indenter; var Emitter = (function () { function Emitter(checker, emittingFileName, outfile, emitOptions, errorReporter) { this.checker = checker; this.emittingFileName = emittingFileName; this.outfile = outfile; this.emitOptions = emitOptions; this.errorReporter = errorReporter; this.prologueEmitted = false; this.thisClassNode = null; this.thisFnc = null; this.moduleDeclList = []; this.moduleName = ""; this.emitState = new EmitState(); this.indenter = new Indenter(); this.ambientModule = false; this.modAliasId = null; this.firstModAlias = null; this.allSourceMappers = []; this.sourceMapper = null; this.captureThisStmtString = "var _this = this;"; this.varListCountStack = [ 0 ]; } Emitter.prototype.setSourceMappings = function (mapper) { this.allSourceMappers.push(mapper); this.sourceMapper = mapper; }; Emitter.prototype.writeToOutput = function (s) { this.outfile.Write(s); this.emitState.column += s.length; }; Emitter.prototype.writeToOutputTrimmable = function (s) { if(this.emitOptions.minWhitespace) { s = s.replace(/[\s]*/g, ''); } this.writeToOutput(s); }; Emitter.prototype.writeLineToOutput = function (s) { if(this.emitOptions.minWhitespace) { this.writeToOutput(s); var c = s.charCodeAt(s.length - 1); if(!((c == TypeScript.LexCodeSpace) || (c == TypeScript.LexCodeSMC) || (c == TypeScript.LexCodeLBR))) { this.writeToOutput(' '); } } else { this.outfile.WriteLine(s); this.emitState.column = 0; this.emitState.line++; } }; Emitter.prototype.writeCaptureThisStatement = function (ast) { this.emitIndent(); this.recordSourceMappingStart(ast); this.writeToOutput(this.captureThisStmtString); this.recordSourceMappingEnd(ast); this.writeLineToOutput(""); }; Emitter.prototype.setInVarBlock = function (count) { this.varListCountStack[this.varListCountStack.length - 1] = count; }; Emitter.prototype.setInObjectLiteral = function (val) { var temp = this.emitState.inObjectLiteral; this.emitState.inObjectLiteral = val; return temp; }; Emitter.prototype.setContainer = function (c) { var temp = this.emitState.container; this.emitState.container = c; return temp; }; Emitter.prototype.getIndentString = function () { if(this.emitOptions.minWhitespace) { return ""; } else { return this.indenter.getIndent(); } }; Emitter.prototype.emitIndent = function () { this.writeToOutput(this.getIndentString()); }; Emitter.prototype.emitCommentInPlace = function (comment) { this.recordSourceMappingStart(comment); var text = comment.getText(); var hadNewLine = false; if(comment.isBlockComment) { if(this.emitState.column == 0) { this.emitIndent(); } this.writeToOutput(text[0]); if(text.length > 1 || comment.endsLine) { this.writeLineToOutput(""); for(var i = 1; i < text.length; i++) { this.emitIndent(); this.writeLineToOutput(text[i]); } hadNewLine = true; } } else { if(this.emitState.column == 0) { this.emitIndent(); } this.writeLineToOutput(text[0]); hadNewLine = true; } if(hadNewLine) { this.emitIndent(); } else { this.writeToOutput(" "); } this.recordSourceMappingEnd(comment); }; Emitter.prototype.emitParensAndCommentsInPlace = function (ast, pre) { var comments = pre ? ast.preComments : ast.postComments; if(ast.isParenthesized && !pre) { this.writeToOutput(")"); } if(this.emitOptions.emitComments && comments && comments.length != 0) { for(var i = 0; i < comments.length; i++) { this.emitCommentInPlace(comments[i]); } } if(ast.isParenthesized && pre) { this.writeToOutput("("); } }; Emitter.prototype.emitObjectLiteral = function (content) { this.writeLineToOutput("{"); this.indenter.increaseIndent(); var inObjectLiteral = this.setInObjectLiteral(true); this.emitJavascriptList(content, ",", TypeScript.TokenID.Comma, true, false, false); this.setInObjectLiteral(inObjectLiteral); this.indenter.decreaseIndent(); this.emitIndent(); this.writeToOutput("}"); }; Emitter.prototype.emitArrayLiteral = function (content) { this.writeToOutput("["); if(content) { this.writeLineToOutput(""); this.indenter.increaseIndent(); this.emitJavascriptList(content, ", ", TypeScript.TokenID.Comma, true, false, false); this.indenter.decreaseIndent(); this.emitIndent(); } this.writeToOutput("]"); }; Emitter.prototype.emitNew = function (target, args) { this.writeToOutput("new "); if(target.nodeType == TypeScript.NodeType.TypeRef) { var typeRef = target; if(typeRef.arrayCount) { this.writeToOutput("Array()"); } else { this.emitJavascript(typeRef.term, TypeScript.TokenID.Tilde, false); this.writeToOutput("()"); } } else { this.emitJavascript(target, TypeScript.TokenID.Tilde, false); this.recordSourceMappingStart(args); this.writeToOutput("("); this.emitJavascriptList(args, ", ", TypeScript.TokenID.Comma, false, false, false); this.writeToOutput(")"); this.recordSourceMappingEnd(args); } }; Emitter.prototype.tryEmitConstant = function (dotExpr) { if(!this.emitOptions.propagateConstants) { return false; } var propertyName = dotExpr.operand2; if(propertyName && propertyName.sym && propertyName.sym.isVariable()) { if(TypeScript.hasFlag(propertyName.sym.flags, TypeScript.SymbolFlags.Constant)) { if(propertyName.sym.declAST) { var boundDecl = propertyName.sym.declAST; if(boundDecl.init && (boundDecl.init.nodeType == TypeScript.NodeType.NumberLit)) { var numLit = boundDecl.init; this.writeToOutput(numLit.value.toString()); var comment = " /* "; comment += propertyName.actualText; comment += " */ "; this.writeToOutput(comment); return true; } } } } return false; }; Emitter.prototype.emitCall = function (callNode, target, args) { if(!this.emitSuperCall(callNode)) { if(!TypeScript.hasFlag(callNode.flags, TypeScript.ASTFlags.ClassBaseConstructorCall)) { if(target.nodeType == TypeScript.NodeType.FuncDecl && !target.isParenthesized) { this.writeToOutput("("); } if(callNode.target.nodeType == TypeScript.NodeType.Super && this.emitState.container == EmitContainer.Constructor) { this.writeToOutput("_super.call"); } else { this.emitJavascript(target, TypeScript.TokenID.OpenParen, false); } if(target.nodeType == TypeScript.NodeType.FuncDecl && !target.isParenthesized) { this.writeToOutput(")"); } this.recordSourceMappingStart(args); this.writeToOutput("("); if(callNode.target.nodeType == TypeScript.NodeType.Super && this.emitState.container == EmitContainer.Constructor) { this.writeToOutput("this"); if(args && args.members.length) { this.writeToOutput(", "); } } this.emitJavascriptList(args, ", ", TypeScript.TokenID.Comma, false, false, false); this.writeToOutput(")"); this.recordSourceMappingEnd(args); } else { this.indenter.decreaseIndent(); this.indenter.decreaseIndent(); var constructorCall = new TypeScript.ASTList(); constructorCall.members[0] = callNode; this.emitConstructorCalls(constructorCall, this.thisClassNode); this.indenter.increaseIndent(); this.indenter.increaseIndent(); } } }; Emitter.prototype.emitConstructorCalls = function (bases, classDecl) { if(bases == null) { return; } var basesLen = bases.members.length; this.recordSourceMappingStart(classDecl); for(var i = 0; i < basesLen; i++) { var baseExpr = bases.members[i]; var baseSymbol = null; if(baseExpr.nodeType == TypeScript.NodeType.Call) { baseSymbol = (baseExpr).target.type.symbol; } else { baseSymbol = baseExpr.type.symbol; } var baseName = baseSymbol.name; if(baseSymbol.declModule != classDecl.type.symbol.declModule) { baseName = baseSymbol.fullName(); } if(baseExpr.nodeType == TypeScript.NodeType.Call) { this.emitIndent(); this.writeToOutput("_super.call(this"); var args = (baseExpr).arguments; if(args && (args.members.length > 0)) { this.writeToOutput(", "); this.emitJavascriptList(args, ", ", TypeScript.TokenID.Comma, false, false, false); } this.writeToOutput(")"); } else { if(baseExpr.type && (baseExpr.type.isClassInstance())) { this.emitIndent(); this.writeToOutput(classDecl.name.actualText + "._super.constructor"); this.writeToOutput(".call(this)"); } } } this.recordSourceMappingEnd(classDecl); }; Emitter.prototype.emitInnerFunction = function (funcDecl, printName, isMember, bases, hasSelfRef, classDecl) { var isClassConstructor = funcDecl.isConstructor && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod); var hasNonObjectBaseType = isClassConstructor && TypeScript.hasFlag(this.thisClassNode.type.instanceType.typeFlags, TypeScript.TypeFlags.HasBaseType) && !TypeScript.hasFlag(this.thisClassNode.type.instanceType.typeFlags, TypeScript.TypeFlags.HasBaseTypeOfObject); var classPropertiesMustComeAfterSuperCall = hasNonObjectBaseType && TypeScript.hasFlag((this.thisClassNode).varFlags, TypeScript.VarFlags.ClassSuperMustBeFirstCallInConstructor); var shouldParenthesize = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.IsFunctionExpression) && !funcDecl.isParenthesized && !funcDecl.isAccessor() && (TypeScript.hasFlag(funcDecl.flags, TypeScript.ASTFlags.ExplicitSemicolon) || TypeScript.hasFlag(funcDecl.flags, TypeScript.ASTFlags.AutomaticSemicolon)); this.emitParensAndCommentsInPlace(funcDecl, true); if(shouldParenthesize) { this.writeToOutput("("); } this.recordSourceMappingStart(funcDecl); if(!(funcDecl.isAccessor() && (funcDecl.accessorSymbol).isObjectLitField)) { this.writeToOutput("function "); } if(printName) { var id = funcDecl.getNameText(); if(id && !funcDecl.isAccessor()) { if(funcDecl.name) { this.recordSourceMappingStart(funcDecl.name); } this.writeToOutput(id); if(funcDecl.name) { this.recordSourceMappingEnd(funcDecl.name); } } } this.writeToOutput("("); var argsLen = 0; var i = 0; var arg; var defaultArgs = []; if(funcDecl.arguments) { var tempContainer = this.setContainer(EmitContainer.Args); argsLen = funcDecl.arguments.members.length; var printLen = argsLen; if(funcDecl.variableArgList) { printLen--; } for(i = 0; i < printLen; i++) { arg = funcDecl.arguments.members[i]; if(arg.init) { defaultArgs.push(arg); } this.emitJavascript(arg, TypeScript.TokenID.OpenParen, false); if(i < (printLen - 1)) { this.writeToOutput(", "); } } this.setContainer(tempContainer); } this.writeLineToOutput(") {"); if(funcDecl.isConstructor) { this.recordSourceMappingNameStart("constructor"); } else { if(funcDecl.isGetAccessor()) { this.recordSourceMappingNameStart("get_" + funcDecl.getNameText()); } else { if(funcDecl.isSetAccessor()) { this.recordSourceMappingNameStart("set_" + funcDecl.getNameText()); } else { this.recordSourceMappingNameStart(funcDecl.getNameText()); } } } this.indenter.increaseIndent(); for(i = 0; i < defaultArgs.length; i++) { var arg = defaultArgs[i]; this.emitIndent(); this.recordSourceMappingStart(arg); this.writeToOutput("if (typeof " + arg.id.actualText + " === \"undefined\") { "); this.recordSourceMappingStart(arg.id); this.writeToOutput(arg.id.actualText); this.recordSourceMappingEnd(arg.id); this.writeToOutput(" = "); this.emitJavascript(arg.init, TypeScript.TokenID.OpenParen, false); this.writeLineToOutput("; }"); this.recordSourceMappingEnd(arg); } if(funcDecl.isConstructor && ((funcDecl.classDecl).varFlags & TypeScript.VarFlags.MustCaptureThis)) { this.writeCaptureThisStatement(funcDecl); } if(funcDecl.isConstructor && !classPropertiesMustComeAfterSuperCall) { if(funcDecl.arguments) { argsLen = funcDecl.arguments.members.length; for(i = 0; i < argsLen; i++) { arg = funcDecl.arguments.members[i]; if((arg.varFlags & TypeScript.VarFlags.Property) != TypeScript.VarFlags.None) { this.emitIndent(); this.recordSourceMappingStart(arg); this.recordSourceMappingStart(arg.id); this.writeToOutput("this." + arg.id.actualText); this.recordSourceMappingEnd(arg.id); this.writeToOutput(" = "); this.recordSourceMappingStart(arg.id); this.writeToOutput(arg.id.actualText); this.recordSourceMappingEnd(arg.id); this.writeLineToOutput(";"); this.recordSourceMappingEnd(arg); } } } if(!TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod)) { this.emitConstructorCalls(bases, classDecl); } } if(hasSelfRef) { this.writeCaptureThisStatement(funcDecl); } if(funcDecl.variableArgList) { argsLen = funcDecl.arguments.members.length; var lastArg = funcDecl.arguments.members[argsLen - 1]; this.emitIndent(); this.recordSourceMappingStart(lastArg); this.writeToOutput("var "); this.recordSourceMappingStart(lastArg.id); this.writeToOutput(lastArg.id.actualText); this.recordSourceMappingEnd(lastArg.id); this.writeLineToOutput(" = [];"); this.recordSourceMappingEnd(lastArg); this.emitIndent(); this.writeToOutput("for ("); this.recordSourceMappingStart(lastArg); this.writeToOutput("var _i = 0;"); this.recordSourceMappingEnd(lastArg); this.writeToOutput(" "); this.recordSourceMappingStart(lastArg); this.writeToOutput("_i < (arguments.length - " + (argsLen - 1) + ")"); this.recordSourceMappingEnd(lastArg); this.writeToOutput("; "); this.recordSourceMappingStart(lastArg); this.writeToOutput("_i++"); this.recordSourceMappingEnd(lastArg); this.writeLineToOutput(") {"); this.indenter.increaseIndent(); this.emitIndent(); this.recordSourceMappingStart(lastArg); this.writeToOutput(lastArg.id.actualText + "[_i] = arguments[_i + " + (argsLen - 1) + "];"); this.recordSourceMappingEnd(lastArg); this.writeLineToOutput(""); this.indenter.decreaseIndent(); this.emitIndent(); this.writeLineToOutput("}"); } if(funcDecl.isConstructor && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod) && !classPropertiesMustComeAfterSuperCall) { var nProps = (this.thisClassNode.members).members.length; for(var i = 0; i < nProps; i++) { if((this.thisClassNode.members).members[i].nodeType == TypeScript.NodeType.VarDecl) { var varDecl = (this.thisClassNode.members).members[i]; if(!TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Static) && varDecl.init) { this.emitIndent(); this.emitJavascriptVarDecl(varDecl, TypeScript.TokenID.Tilde); this.writeLineToOutput(""); } } } } this.emitBareJavascriptStatements(funcDecl.bod, classPropertiesMustComeAfterSuperCall); this.indenter.decreaseIndent(); this.emitIndent(); this.recordSourceMappingStart(funcDecl.endingToken); this.writeToOutput("}"); this.recordSourceMappingNameEnd(); this.recordSourceMappingEnd(funcDecl.endingToken); this.recordSourceMappingEnd(funcDecl); if(shouldParenthesize) { this.writeToOutput(")"); } this.recordSourceMappingEnd(funcDecl); this.emitParensAndCommentsInPlace(funcDecl, false); if(!isMember && !TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.IsFunctionExpression) && (TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Definition) || funcDecl.isConstructor)) { this.writeLineToOutput(""); } else { if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.IsFunctionExpression)) { if(TypeScript.hasFlag(funcDecl.flags, TypeScript.ASTFlags.ExplicitSemicolon) || TypeScript.hasFlag(funcDecl.flags, TypeScript.ASTFlags.AutomaticSemicolon)) { this.writeLineToOutput(";"); } } } }; Emitter.prototype.emitJavascriptModule = function (moduleDecl) { var modName = moduleDecl.name.actualText; if(TypeScript.isTSFile(modName)) { moduleDecl.name.setText(modName.substring(0, modName.length - 3)); } else { if(TypeScript.isSTRFile(modName)) { moduleDecl.name.setText(modName.substring(0, modName.length - 4)); } } if(!TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.Ambient)) { var isDynamicMod = TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsDynamic); var prevOutFile = this.outfile; var prevOutFileName = this.emittingFileName; var prevAllSourceMappers = this.allSourceMappers; var prevSourceMapper = this.sourceMapper; var prevColumn = this.emitState.column; var prevLine = this.emitState.line; var temp = this.setContainer(EmitContainer.Module); var svModuleName = this.moduleName; var isExported = TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.Exported); this.moduleDeclList[this.moduleDeclList.length] = moduleDecl; var isWholeFile = TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsWholeFile); this.moduleName = moduleDecl.name.actualText; if(isDynamicMod) { var tsModFileName = TypeScript.stripQuotes(moduleDecl.name.actualText); var modFilePath = TypeScript.trimModName(tsModFileName) + ".js"; modFilePath = this.emitOptions.mapOutputFileName(modFilePath, TypeScript.TypeScriptCompiler.mapToJSFileName); if(this.emitOptions.ioHost) { if(TypeScript.switchToForwardSlashes(modFilePath) != TypeScript.switchToForwardSlashes(this.emittingFileName)) { this.emittingFileName = modFilePath; var useUTF8InOutputfile = moduleDecl.containsUnicodeChar || (this.emitOptions.emitComments && moduleDecl.containsUnicodeCharInComment); this.outfile = this.createFile(this.emittingFileName, useUTF8InOutputfile); if(prevSourceMapper != null) { this.allSourceMappers = []; var sourceMappingFile = this.createFile(this.emittingFileName + TypeScript.SourceMapper.MapFileExtension, false); this.setSourceMappings(new TypeScript.SourceMapper(tsModFileName, this.emittingFileName, this.outfile, sourceMappingFile, this.errorReporter)); this.emitState.column = 0; this.emitState.line = 0; } } else { TypeScript.CompilerDiagnostics.assert(this.emitOptions.outputMany, "Cannot have dynamic modules compiling into single file"); } } this.setContainer(EmitContainer.DynamicModule); this.recordSourceMappingStart(moduleDecl); if(TypeScript.moduleGenTarget == TypeScript.ModuleGenTarget.Asynchronous) { var dependencyList = "[\"require\", \"exports\""; var importList = "require, exports"; var importStatement = null; for(var i = 0; i < (moduleDecl.mod).importedModules.length; i++) { importStatement = (moduleDecl.mod).importedModules[i]; if(importStatement.id.sym && !(importStatement.id.sym).onlyReferencedAsTypeRef) { if(i <= (moduleDecl.mod).importedModules.length - 1) { dependencyList += ", "; importList += ", "; } importList += "__" + importStatement.id.actualText + "__"; dependencyList += importStatement.firstAliasedModToString(); } } for(var i = 0; i < moduleDecl.amdDependencies.length; i++) { dependencyList += ", \"" + moduleDecl.amdDependencies[i] + "\""; } dependencyList += "]"; this.writeLineToOutput("define(" + dependencyList + "," + " function(" + importList + ") {"); } else { } } else { if(!isExported) { this.recordSourceMappingStart(moduleDecl); this.writeToOutput("var "); this.recordSourceMappingStart(moduleDecl.name); this.writeToOutput(this.moduleName); this.recordSourceMappingEnd(moduleDecl.name); this.writeLineToOutput(";"); this.recordSourceMappingEnd(moduleDecl); this.emitIndent(); } this.writeToOutput("("); this.recordSourceMappingStart(moduleDecl); this.writeToOutput("function ("); this.recordSourceMappingStart(moduleDecl.name); this.writeToOutput(this.moduleName); this.recordSourceMappingEnd(moduleDecl.name); this.writeLineToOutput(") {"); } if(!isWholeFile) { this.recordSourceMappingNameStart(this.moduleName); } if(!isDynamicMod || TypeScript.moduleGenTarget == TypeScript.ModuleGenTarget.Asynchronous) { this.indenter.increaseIndent(); } if(moduleDecl.modFlags & TypeScript.ModuleFlags.MustCaptureThis) { this.writeCaptureThisStatement(moduleDecl); } this.emitJavascriptList(moduleDecl.members, null, TypeScript.TokenID.Semicolon, true, false, false); if(!isDynamicMod || TypeScript.moduleGenTarget == TypeScript.ModuleGenTarget.Asynchronous) { this.indenter.decreaseIndent(); } this.emitIndent(); if(isDynamicMod) { if(TypeScript.moduleGenTarget == TypeScript.ModuleGenTarget.Asynchronous) { this.writeLineToOutput("})"); } else { } if(!isWholeFile) { this.recordSourceMappingNameEnd(); } this.recordSourceMappingEnd(moduleDecl); if(this.outfile != prevOutFile) { this.Close(); if(prevSourceMapper != null) { this.allSourceMappers = prevAllSourceMappers; this.sourceMapper = prevSourceMapper; this.emitState.column = prevColumn; this.emitState.line = prevLine; } this.outfile = prevOutFile; this.emittingFileName = prevOutFileName; } } else { var containingMod = null; if(moduleDecl.type && moduleDecl.type.symbol.container && moduleDecl.type.symbol.container.declAST) { containingMod = moduleDecl.type.symbol.container.declAST; } var parentIsDynamic = containingMod && TypeScript.hasFlag(containingMod.modFlags, TypeScript.ModuleFlags.IsDynamic); this.recordSourceMappingStart(moduleDecl.endingToken); if(temp == EmitContainer.Prog && isExported) { this.writeToOutput("}"); if(!isWholeFile) { this.recordSourceMappingNameEnd(); } this.recordSourceMappingEnd(moduleDecl.endingToken); this.writeLineToOutput(")(this." + this.moduleName + " || (this." + this.moduleName + " = {}));"); } else { if(isExported || temp == EmitContainer.Prog) { var dotMod = svModuleName != "" ? (parentIsDynamic ? "exports" : svModuleName) + "." : svModuleName; this.writeToOutput("}"); if(!isWholeFile) { this.recordSourceMappingNameEnd(); } this.recordSourceMappingEnd(moduleDecl.endingToken); this.writeLineToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));"); } else { if(!isExported && temp != EmitContainer.Prog) { this.writeToOutput("}"); if(!isWholeFile) { this.recordSourceMappingNameEnd(); } this.recordSourceMappingEnd(moduleDecl.endingToken); this.writeLineToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));"); } else { this.writeToOutput("}"); if(!isWholeFile) { this.recordSourceMappingNameEnd(); } this.recordSourceMappingEnd(moduleDecl.endingToken); this.writeLineToOutput(")();"); } } } this.recordSourceMappingEnd(moduleDecl); if(temp != EmitContainer.Prog && isExported) { this.emitIndent(); this.recordSourceMappingStart(moduleDecl); if(parentIsDynamic) { this.writeLineToOutput("var " + this.moduleName + " = exports." + this.moduleName + ";"); } else { this.writeLineToOutput("var " + this.moduleName + " = " + svModuleName + "." + this.moduleName + ";"); } this.recordSourceMappingEnd(moduleDecl); } } this.setContainer(temp); this.moduleName = svModuleName; this.moduleDeclList.length--; } }; Emitter.prototype.emitIndex = function (operand1, operand2) { var temp = this.setInObjectLiteral(false); this.emitJavascript(operand1, TypeScript.TokenID.Tilde, false); this.writeToOutput("["); this.emitJavascriptList(operand2, ", ", TypeScript.TokenID.Comma, false, false, false); this.writeToOutput("]"); this.setInObjectLiteral(temp); }; Emitter.prototype.emitStringLiteral = function (text) { this.writeToOutput(text); }; Emitter.prototype.emitJavascriptFunction = function (funcDecl) { if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Signature) || funcDecl.isOverload) { return; } var temp; var tempFnc = this.thisFnc; this.thisFnc = funcDecl; if(funcDecl.isConstructor) { temp = this.setContainer(EmitContainer.Constructor); } else { temp = this.setContainer(EmitContainer.Function); } var bases = null; var hasSelfRef = false; var funcName = funcDecl.getNameText(); if((this.emitState.inObjectLiteral || !funcDecl.isAccessor()) && ((temp != EmitContainer.Constructor) || ((funcDecl.fncFlags & TypeScript.FncFlags.Method) == TypeScript.FncFlags.None))) { var tempLit = this.setInObjectLiteral(false); if(this.thisClassNode) { bases = this.thisClassNode.extendsList; } hasSelfRef = Emitter.shouldCaptureThis(funcDecl); this.recordSourceMappingStart(funcDecl); if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Exported | TypeScript.FncFlags.ClassPropertyMethodExported) && funcDecl.type.symbol.container == this.checker.gloMod && !funcDecl.isConstructor) { this.writeToOutput("this." + funcName + " = "); this.emitInnerFunction(funcDecl, false, false, bases, hasSelfRef, this.thisClassNode); } else { this.emitInnerFunction(funcDecl, (funcDecl.name && !funcDecl.name.isMissing()), false, bases, hasSelfRef, this.thisClassNode); } this.setInObjectLiteral(tempLit); } this.setContainer(temp); this.thisFnc = tempFnc; if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Definition)) { if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Static)) { if(this.thisClassNode) { if(funcDecl.isAccessor()) { this.emitPropertyAccessor(funcDecl, this.thisClassNode.name.actualText, false); } else { this.emitIndent(); this.recordSourceMappingStart(funcDecl); this.writeLineToOutput(this.thisClassNode.name.actualText + "." + funcName + " = " + funcName + ";"); this.recordSourceMappingEnd(funcDecl); } } } else { if((this.emitState.container == EmitContainer.Module || this.emitState.container == EmitContainer.DynamicModule) && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Exported | TypeScript.FncFlags.ClassPropertyMethodExported)) { this.emitIndent(); var modName = this.emitState.container == EmitContainer.Module ? this.moduleName : "exports"; this.recordSourceMappingStart(funcDecl); this.writeLineToOutput(modName + "." + funcName + " = " + funcName + ";"); this.recordSourceMappingEnd(funcDecl); } } } }; Emitter.prototype.emitAmbientVarDecl = function (varDecl) { if(varDecl.init) { this.emitParensAndCommentsInPlace(varDecl, true); this.recordSourceMappingStart(varDecl); this.recordSourceMappingStart(varDecl.id); this.writeToOutput(varDecl.id.actualText); this.recordSourceMappingEnd(varDecl.id); this.writeToOutput(" = "); this.emitJavascript(varDecl.init, TypeScript.TokenID.Comma, false); this.recordSourceMappingEnd(varDecl); this.writeToOutput(";"); this.emitParensAndCommentsInPlace(varDecl, false); } }; Emitter.prototype.varListCount = function () { return this.varListCountStack[this.varListCountStack.length - 1]; }; Emitter.prototype.emitVarDeclVar = function () { if(this.varListCount() >= 0) { this.writeToOutput("var "); this.setInVarBlock(-this.varListCount()); } return true; }; Emitter.prototype.onEmitVar = function () { if(this.varListCount() > 0) { this.setInVarBlock(this.varListCount() - 1); } else { if(this.varListCount() < 0) { this.setInVarBlock(this.varListCount() + 1); } } }; Emitter.prototype.emitJavascriptVarDecl = function (varDecl, tokenId) { if((varDecl.varFlags & TypeScript.VarFlags.Ambient) == TypeScript.VarFlags.Ambient) { this.emitAmbientVarDecl(varDecl); this.onEmitVar(); } else { var sym = varDecl.sym; var hasInitializer = (varDecl.init != null); this.emitParensAndCommentsInPlace(varDecl, true); this.recordSourceMappingStart(varDecl); if(sym && sym.isMember() && sym.container && (sym.container.kind() == TypeScript.SymbolKind.Type)) { var type = (sym.container).type; if(type.isClass() && (!TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.ModuleMember))) { if(this.emitState.container != EmitContainer.Args) { if(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Static)) { this.writeToOutput(sym.container.name + "."); } else { this.writeToOutput("this."); } } } else { if(type.hasImplementation()) { if(!TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Exported) && (sym.container == this.checker.gloMod || !TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Property))) { this.emitVarDeclVar(); } else { if(TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.LocalStatic)) { this.writeToOutput("."); } else { if(this.emitState.container == EmitContainer.DynamicModule) { this.writeToOutput("exports."); } else { this.writeToOutput(this.moduleName + "."); } } } } else { if(tokenId != TypeScript.TokenID.OpenParen) { if(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Exported) && sym.container == this.checker.gloMod) { this.writeToOutput("this."); } else { this.emitVarDeclVar(); } } } } } else { if(tokenId != TypeScript.TokenID.OpenParen) { this.emitVarDeclVar(); } } this.recordSourceMappingStart(varDecl.id); this.writeToOutput(varDecl.id.actualText); this.recordSourceMappingEnd(varDecl.id); if(hasInitializer) { this.writeToOutputTrimmable(" = "); this.varListCountStack.push(0); this.emitJavascript(varDecl.init, TypeScript.TokenID.Comma, false); this.varListCountStack.pop(); } this.onEmitVar(); if((tokenId != TypeScript.TokenID.OpenParen)) { if(this.varListCount() < 0) { this.writeToOutput(", "); } else { if(tokenId != TypeScript.TokenID.For) { this.writeToOutputTrimmable(";"); } } } this.recordSourceMappingEnd(varDecl); this.emitParensAndCommentsInPlace(varDecl, false); } }; Emitter.prototype.declEnclosed = function (moduleDecl) { if(moduleDecl == null) { return true; } for(var i = 0, len = this.moduleDeclList.length; i < len; i++) { if(this.moduleDeclList[i] == moduleDecl) { return true; } } return false; }; Emitter.prototype.emitJavascriptName = function (name, addThis) { var sym = name.sym; this.emitParensAndCommentsInPlace(name, true); this.recordSourceMappingStart(name); if(!name.isMissing()) { if(addThis && (this.emitState.container != EmitContainer.Args) && sym) { if(sym.container && (sym.container.name != TypeScript.globalId)) { if(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Static) && (TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Property))) { if(sym.declModule && TypeScript.hasFlag(sym.declModule.modFlags, TypeScript.ModuleFlags.IsDynamic)) { this.writeToOutput("exports."); } else { this.writeToOutput(sym.container.name + "."); } } else { if(sym.kind() == TypeScript.SymbolKind.Field) { var fieldSym = sym; if(TypeScript.hasFlag(fieldSym.flags, TypeScript.SymbolFlags.ModuleMember)) { if((sym.container != this.checker.gloMod) && ((TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Property)) || TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Exported))) { if(TypeScript.hasFlag(sym.declModule.modFlags, TypeScript.ModuleFlags.IsDynamic)) { this.writeToOutput("exports."); } else { this.writeToOutput(sym.container.name + "."); } } } else { if(sym.isInstanceProperty()) { this.emitThis(); this.writeToOutput("."); } } } else { if(sym.kind() == TypeScript.SymbolKind.Type) { if(sym.isInstanceProperty()) { var typeSym = sym; var type = typeSym.type; if(type.call && !TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.ModuleMember)) { this.emitThis(); this.writeToOutput("."); } } else { if((sym.unitIndex != this.checker.locationInfo.unitIndex) || (!this.declEnclosed(sym.declModule))) { this.writeToOutput(sym.container.name + "."); } } } } } } else { if(sym.container == this.checker.gloMod && TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Exported) && !TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Ambient) && !((sym.isType() || sym.isMember()) && sym.declModule && TypeScript.hasFlag(sym.declModule.modFlags, TypeScript.ModuleFlags.Ambient)) && this.emitState.container == EmitContainer.Prog && sym.declAST.nodeType != TypeScript.NodeType.FuncDecl) { this.writeToOutput("this."); } } } if(sym && sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.ModuleDeclaration && (TypeScript.hasFlag((sym.declAST).modFlags, TypeScript.ModuleFlags.IsDynamic))) { var moduleDecl = sym.declAST; if(TypeScript.moduleGenTarget == TypeScript.ModuleGenTarget.Asynchronous) { this.writeLineToOutput("__" + this.modAliasId + "__;"); } else { var modPath = name.actualText; var isAmbient = moduleDecl.mod.symbol.declAST && TypeScript.hasFlag((moduleDecl.mod.symbol.declAST).modFlags, TypeScript.ModuleFlags.Ambient); modPath = isAmbient ? modPath : this.firstModAlias ? this.firstModAlias : TypeScript.quoteBaseName(modPath); modPath = isAmbient ? modPath : (!TypeScript.isRelative(TypeScript.stripQuotes(modPath)) ? TypeScript.quoteStr("./" + TypeScript.stripQuotes(modPath)) : modPath); this.writeToOutput("require(" + modPath + ")"); } } else { this.writeToOutput(name.actualText); } } this.recordSourceMappingEnd(name); this.emitParensAndCommentsInPlace(name, false); }; Emitter.prototype.emitJavascriptStatements = function (stmts, emitEmptyBod) { if(stmts) { if(stmts.nodeType != TypeScript.NodeType.Block) { var hasContents = (stmts && (stmts.nodeType != TypeScript.NodeType.List || ((stmts).members.length > 0))); if(emitEmptyBod || hasContents) { var hasOnlyBlockStatement = ((stmts.nodeType == TypeScript.NodeType.Block) || ((stmts.nodeType == TypeScript.NodeType.List) && ((stmts).members.length == 1) && ((stmts).members[0].nodeType == TypeScript.NodeType.Block))); this.recordSourceMappingStart(stmts); if(!hasOnlyBlockStatement) { this.writeLineToOutput(" {"); this.indenter.increaseIndent(); } this.emitJavascriptList(stmts, null, TypeScript.TokenID.Semicolon, true, false, false); if(!hasOnlyBlockStatement) { this.writeLineToOutput(""); this.indenter.decreaseIndent(); this.emitIndent(); this.writeToOutput("}"); } this.recordSourceMappingEnd(stmts); } } else { this.emitJavascript(stmts, TypeScript.TokenID.Semicolon, true); } } else { if(emitEmptyBod) { this.writeToOutput("{ }"); } } }; Emitter.prototype.emitBareJavascriptStatements = function (stmts, emitClassPropertiesAfterSuperCall) { if (typeof emitClassPropertiesAfterSuperCall === "undefined") { emitClassPropertiesAfterSuperCall = false; } if(stmts.nodeType != TypeScript.NodeType.Block) { if(stmts.nodeType == TypeScript.NodeType.List) { var stmtList = stmts; if((stmtList.members.length == 2) && (stmtList.members[0].nodeType == TypeScript.NodeType.Block) && (stmtList.members[1].nodeType == TypeScript.NodeType.EndCode)) { this.emitJavascript(stmtList.members[0], TypeScript.TokenID.Semicolon, true); this.writeLineToOutput(""); } else { this.emitJavascriptList(stmts, null, TypeScript.TokenID.Semicolon, true, false, emitClassPropertiesAfterSuperCall); } } else { this.emitJavascript(stmts, TypeScript.TokenID.Semicolon, true); } } else { this.emitJavascript(stmts, TypeScript.TokenID.Semicolon, true); } }; Emitter.prototype.recordSourceMappingNameStart = function (name) { if(this.sourceMapper) { var finalName = name; if(!name) { finalName = ""; } else { if(this.sourceMapper.currentNameIndex.length > 0) { finalName = this.sourceMapper.names[this.sourceMapper.currentNameIndex.length - 1] + "." + name; } } this.sourceMapper.names.push(finalName); this.sourceMapper.currentNameIndex.push(this.sourceMapper.names.length - 1); } }; Emitter.prototype.recordSourceMappingNameEnd = function () { if(this.sourceMapper) { this.sourceMapper.currentNameIndex.pop(); } }; Emitter.prototype.recordSourceMappingStart = function (ast) { if(this.sourceMapper && TypeScript.isValidAstNode(ast)) { var lineCol = { line: -1, col: -1 }; var sourceMapping = new TypeScript.SourceMapping(); sourceMapping.start.emittedColumn = this.emitState.column; sourceMapping.start.emittedLine = this.emitState.line; TypeScript.getSourceLineColFromMap(lineCol, ast.minChar, this.checker.locationInfo.lineMap); sourceMapping.start.sourceColumn = lineCol.col; sourceMapping.start.sourceLine = lineCol.line; TypeScript.getSourceLineColFromMap(lineCol, ast.limChar, this.checker.locationInfo.lineMap); sourceMapping.end.sourceColumn = lineCol.col; sourceMapping.end.sourceLine = lineCol.line; if(this.sourceMapper.currentNameIndex.length > 0) { sourceMapping.nameIndex = this.sourceMapper.currentNameIndex[this.sourceMapper.currentNameIndex.length - 1]; } var siblings = this.sourceMapper.currentMappings[this.sourceMapper.currentMappings.length - 1]; siblings.push(sourceMapping); this.sourceMapper.currentMappings.push(sourceMapping.childMappings); } }; Emitter.prototype.recordSourceMappingEnd = function (ast) { if(this.sourceMapper && TypeScript.isValidAstNode(ast)) { this.sourceMapper.currentMappings.pop(); var siblings = this.sourceMapper.currentMappings[this.sourceMapper.currentMappings.length - 1]; var sourceMapping = siblings[siblings.length - 1]; sourceMapping.end.emittedColumn = this.emitState.column; sourceMapping.end.emittedLine = this.emitState.line; } }; Emitter.prototype.Close = function () { if(this.sourceMapper != null) { TypeScript.SourceMapper.EmitSourceMapping(this.allSourceMappers); } try { this.outfile.Close(); } catch (ex) { this.errorReporter.emitterError(null, ex.message); } }; Emitter.prototype.emitJavascriptList = function (ast, delimiter, tokenId, startLine, onlyStatics, emitClassPropertiesAfterSuperCall, emitPrologue, requiresExtendsBlock) { if (typeof emitClassPropertiesAfterSuperCall === "undefined") { emitClassPropertiesAfterSuperCall = false; } if (typeof emitPrologue === "undefined") { emitPrologue = false; } if(ast == null) { return; } else { if(ast.nodeType != TypeScript.NodeType.List) { this.emitPrologue(emitPrologue); this.emitJavascript(ast, tokenId, startLine); } else { var list = ast; if(list.members.length == 0) { return; } this.emitParensAndCommentsInPlace(ast, true); var len = list.members.length; for(var i = 0; i < len; i++) { if(emitPrologue) { if(i == 1 || !TypeScript.hasFlag(list.flags, TypeScript.ASTFlags.StrictMode)) { this.emitPrologue(requiresExtendsBlock); emitPrologue = false; } } if(i == 1 && emitClassPropertiesAfterSuperCall) { var constructorDecl = (this.thisClassNode).constructorDecl; if(constructorDecl && constructorDecl.arguments) { var argsLen = constructorDecl.arguments.members.length; for(var iArg = 0; iArg < argsLen; iArg++) { var arg = constructorDecl.arguments.members[iArg]; if((arg.varFlags & TypeScript.VarFlags.Property) != TypeScript.VarFlags.None) { this.emitIndent(); this.recordSourceMappingStart(arg); this.recordSourceMappingStart(arg.id); this.writeToOutput("this." + arg.id.actualText); this.recordSourceMappingEnd(arg.id); this.writeToOutput(" = "); this.recordSourceMappingStart(arg.id); this.writeToOutput(arg.id.actualText); this.recordSourceMappingEnd(arg.id); this.writeLineToOutput(";"); this.recordSourceMappingEnd(arg); } } } var nProps = (this.thisClassNode.members).members.length; for(var iMember = 0; iMember < nProps; iMember++) { if((this.thisClassNode.members).members[iMember].nodeType == TypeScript.NodeType.VarDecl) { var varDecl = (this.thisClassNode.members).members[iMember]; if(!TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Static) && varDecl.init) { this.emitIndent(); this.emitJavascriptVarDecl(varDecl, TypeScript.TokenID.Tilde); this.writeLineToOutput(""); } } } } var emitNode = list.members[i]; var isStaticDecl = (emitNode.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((emitNode).fncFlags, TypeScript.FncFlags.Static)) || (emitNode.nodeType == TypeScript.NodeType.VarDecl && TypeScript.hasFlag((emitNode).varFlags, TypeScript.VarFlags.Static)); if(onlyStatics ? !isStaticDecl : isStaticDecl) { continue; } this.emitJavascript(emitNode, tokenId, startLine); if(delimiter && (i < (len - 1))) { if(startLine) { this.writeLineToOutput(delimiter); } else { this.writeToOutput(delimiter); } } else { if(startLine && (emitNode.nodeType != TypeScript.NodeType.ModuleDeclaration) && (emitNode.nodeType != TypeScript.NodeType.InterfaceDeclaration) && (!((emitNode.nodeType == TypeScript.NodeType.VarDecl) && ((((emitNode).varFlags) & TypeScript.VarFlags.Ambient) == TypeScript.VarFlags.Ambient) && (((emitNode).init) == null)) && this.varListCount() >= 0) && (emitNode.nodeType != TypeScript.NodeType.Block || (emitNode).isStatementBlock) && (emitNode.nodeType != TypeScript.NodeType.EndCode) && (emitNode.nodeType != TypeScript.NodeType.FuncDecl)) { this.writeLineToOutput(""); } } } this.emitParensAndCommentsInPlace(ast, false); } } }; Emitter.prototype.emitJavascript = function (ast, tokenId, startLine) { if(ast == null) { return; } if(startLine && (this.indenter.indentAmt > 0) && (ast.nodeType != TypeScript.NodeType.List) && (ast.nodeType != TypeScript.NodeType.Block)) { if((ast.nodeType != TypeScript.NodeType.InterfaceDeclaration) && (!((ast.nodeType == TypeScript.NodeType.VarDecl) && ((((ast).varFlags) & TypeScript.VarFlags.Ambient) == TypeScript.VarFlags.Ambient) && (((ast).init) == null)) && this.varListCount() >= 0) && (ast.nodeType != TypeScript.NodeType.EndCode) && ((ast.nodeType != TypeScript.NodeType.FuncDecl) || (this.emitState.container != EmitContainer.Constructor))) { this.emitIndent(); } } ast.emit(this, tokenId, startLine); if((tokenId == TypeScript.TokenID.Semicolon) && (ast.nodeType < TypeScript.NodeType.GeneralNode)) { this.writeToOutput(";"); } }; Emitter.prototype.emitPropertyAccessor = function (funcDecl, className, isProto) { if(!(funcDecl.accessorSymbol).hasBeenEmitted) { var accessorSymbol = funcDecl.accessorSymbol; this.emitIndent(); this.recordSourceMappingStart(funcDecl); this.writeLineToOutput("Object.defineProperty(" + className + (isProto ? ".prototype, \"" : ", \"") + funcDecl.name.actualText + "\"" + ", {"); this.indenter.increaseIndent(); if(accessorSymbol.getter) { var getter = accessorSymbol.getter.declAST; this.emitIndent(); this.recordSourceMappingStart(getter); this.writeToOutput("get: "); this.emitInnerFunction(getter, false, isProto, null, Emitter.shouldCaptureThis(getter), null); this.writeLineToOutput(","); } if(accessorSymbol.setter) { var setter = accessorSymbol.setter.declAST; this.emitIndent(); this.recordSourceMappingStart(setter); this.writeToOutput("set: "); this.emitInnerFunction(setter, false, isProto, null, Emitter.shouldCaptureThis(setter), null); this.writeLineToOutput(","); } this.emitIndent(); this.writeLineToOutput("enumerable: true,"); this.emitIndent(); this.writeLineToOutput("configurable: true"); this.indenter.decreaseIndent(); this.emitIndent(); this.writeLineToOutput("});"); this.recordSourceMappingEnd(funcDecl); accessorSymbol.hasBeenEmitted = true; } }; Emitter.prototype.emitPrototypeMember = function (member, className) { if(member.nodeType == TypeScript.NodeType.FuncDecl) { var funcDecl = member; if(funcDecl.isAccessor()) { this.emitPropertyAccessor(funcDecl, className, true); } else { this.emitIndent(); this.recordSourceMappingStart(funcDecl); this.writeToOutput(className + ".prototype." + funcDecl.getNameText() + " = "); this.emitInnerFunction(funcDecl, false, true, null, Emitter.shouldCaptureThis(funcDecl), null); this.writeLineToOutput(";"); } } else { if(member.nodeType == TypeScript.NodeType.VarDecl) { var varDecl = member; if(varDecl.init) { this.emitIndent(); this.recordSourceMappingStart(varDecl); this.recordSourceMappingStart(varDecl.id); this.writeToOutput(className + ".prototype." + varDecl.id.actualText); this.recordSourceMappingEnd(varDecl.id); this.writeToOutput(" = "); this.emitJavascript(varDecl.init, TypeScript.TokenID.Equals, false); this.recordSourceMappingEnd(varDecl); this.writeLineToOutput(";"); } } } }; Emitter.prototype.emitAddBaseMethods = function (className, base, classDecl) { if(base.members) { var baseSymbol = base.symbol; var baseName = baseSymbol.name; if(baseSymbol.declModule != classDecl.type.symbol.declModule) { baseName = baseSymbol.fullName(); } base.members.allMembers.map(function (key, s, c) { var sym = s; if((sym.kind() == TypeScript.SymbolKind.Type) && (sym).type.call) { this.recordSourceMappingStart(sym.declAST); this.writeLineToOutput(className + ".prototype." + sym.name + " = " + baseName + ".prototype." + sym.name + ";"); this.recordSourceMappingEnd(sym.declAST); } }, null); } if(base.extendsList) { for(var i = 0, len = base.extendsList.length; i < len; i++) { this.emitAddBaseMethods(className, base.extendsList[i], classDecl); } } }; Emitter.prototype.emitJavascriptClass = function (classDecl) { if(!TypeScript.hasFlag(classDecl.varFlags, TypeScript.VarFlags.Ambient)) { var svClassNode = this.thisClassNode; var i = 0; this.thisClassNode = classDecl; var className = classDecl.name.actualText; this.emitParensAndCommentsInPlace(classDecl, true); var temp = this.setContainer(EmitContainer.Class); this.recordSourceMappingStart(classDecl); if(TypeScript.hasFlag(classDecl.varFlags, TypeScript.VarFlags.Exported) && classDecl.type.symbol.container == this.checker.gloMod) { this.writeToOutput("this." + className); } else { this.writeToOutput("var " + className); } var hasBaseClass = classDecl.extendsList && classDecl.extendsList.members.length; var baseNameDecl = null; var baseName = null; if(hasBaseClass) { this.writeLineToOutput(" = (function (_super) {"); } else { this.writeLineToOutput(" = (function () {"); } this.recordSourceMappingNameStart(className); this.indenter.increaseIndent(); if(hasBaseClass) { baseNameDecl = classDecl.extendsList.members[0]; baseName = baseNameDecl.nodeType == TypeScript.NodeType.Call ? (baseNameDecl).target : baseNameDecl; this.emitIndent(); this.writeLineToOutput("__extends(" + className + ", _super);"); } this.emitIndent(); var constrDecl = classDecl.constructorDecl; if(constrDecl) { this.emitJavascript(classDecl.constructorDecl, TypeScript.TokenID.OpenParen, false); } else { var wroteProps = 0; this.recordSourceMappingStart(classDecl); this.indenter.increaseIndent(); this.writeToOutput("function " + classDecl.name.actualText + "() {"); this.recordSourceMappingNameStart("constructor"); if(hasBaseClass) { this.writeLineToOutput(""); this.emitIndent(); this.writeLineToOutput("_super.apply(this, arguments);"); wroteProps++; } if(classDecl.varFlags & TypeScript.VarFlags.MustCaptureThis) { this.writeCaptureThisStatement(classDecl); } var members = (this.thisClassNode.members).members; for(var i = 0; i < members.length; i++) { if(members[i].nodeType == TypeScript.NodeType.VarDecl) { var varDecl = members[i]; if(!TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Static) && varDecl.init) { this.writeLineToOutput(""); this.emitIndent(); this.emitJavascriptVarDecl(varDecl, TypeScript.TokenID.Tilde); wroteProps++; } } } if(wroteProps) { this.writeLineToOutput(""); this.indenter.decreaseIndent(); this.emitIndent(); this.writeLineToOutput("}"); } else { this.writeLineToOutput(" }"); this.indenter.decreaseIndent(); } this.recordSourceMappingNameEnd(); this.recordSourceMappingEnd(classDecl); } var membersLen = classDecl.members.members.length; for(var j = 0; j < membersLen; j++) { var memberDecl = classDecl.members.members[j]; if(memberDecl.nodeType == TypeScript.NodeType.FuncDecl) { var fn = memberDecl; if(TypeScript.hasFlag(fn.fncFlags, TypeScript.FncFlags.Method) && !fn.isSignature()) { if(!TypeScript.hasFlag(fn.fncFlags, TypeScript.FncFlags.Static)) { this.emitPrototypeMember(fn, className); } else { if(fn.isAccessor()) { this.emitPropertyAccessor(fn, this.thisClassNode.name.actualText, false); } else { this.emitIndent(); this.recordSourceMappingStart(fn); this.writeToOutput(classDecl.name.actualText + "." + fn.name.actualText + " = "); this.emitInnerFunction(fn, (fn.name && !fn.name.isMissing()), true, null, Emitter.shouldCaptureThis(fn), null); this.writeLineToOutput(";"); } } } } else { if(memberDecl.nodeType == TypeScript.NodeType.VarDecl) { var varDecl = memberDecl; if(TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Static)) { if(varDecl.init) { this.emitIndent(); this.recordSourceMappingStart(varDecl); this.writeToOutput(classDecl.name.actualText + "." + varDecl.id.actualText + " = "); this.emitJavascript(varDecl.init, TypeScript.TokenID.Equals, false); this.writeLineToOutput(";"); this.recordSourceMappingEnd(varDecl); } } } else { throw Error("We want to catch this"); } } } this.emitIndent(); this.recordSourceMappingStart(classDecl.endingToken); this.writeLineToOutput("return " + className + ";"); this.recordSourceMappingEnd(classDecl.endingToken); this.indenter.decreaseIndent(); this.emitIndent(); this.recordSourceMappingStart(classDecl.endingToken); this.writeToOutput("}"); this.recordSourceMappingNameEnd(); this.recordSourceMappingEnd(classDecl.endingToken); this.recordSourceMappingStart(classDecl); this.writeToOutput(")("); if(hasBaseClass) { this.emitJavascript(baseName, TypeScript.TokenID.Tilde, false); } this.writeToOutput(");"); this.recordSourceMappingEnd(classDecl); if((temp == EmitContainer.Module || temp == EmitContainer.DynamicModule) && TypeScript.hasFlag(classDecl.varFlags, TypeScript.VarFlags.Exported)) { this.writeLineToOutput(""); this.emitIndent(); var modName = temp == EmitContainer.Module ? this.moduleName : "exports"; this.recordSourceMappingStart(classDecl); this.writeToOutput(modName + "." + className + " = " + className + ";"); this.recordSourceMappingEnd(classDecl); } this.emitIndent(); this.recordSourceMappingEnd(classDecl); this.emitParensAndCommentsInPlace(classDecl, false); this.setContainer(temp); this.thisClassNode = svClassNode; } }; Emitter.prototype.emitPrologue = function (reqInherits) { if(!this.prologueEmitted) { if(reqInherits) { this.prologueEmitted = true; this.writeLineToOutput("var __extends = this.__extends || function (d, b) {"); this.writeLineToOutput(" function __() { this.constructor = d; }"); this.writeLineToOutput(" __.prototype = b.prototype;"); this.writeLineToOutput(" d.prototype = new __();"); this.writeLineToOutput("};"); } if(this.checker.mustCaptureGlobalThis) { this.prologueEmitted = true; this.writeLineToOutput(this.captureThisStmtString); } } }; Emitter.prototype.emitSuperReference = function () { this.writeToOutput("_super.prototype"); }; Emitter.prototype.emitSuperCall = function (callEx) { if(callEx.target.nodeType == TypeScript.NodeType.Dot) { var dotNode = callEx.target; if(dotNode.operand1.nodeType == TypeScript.NodeType.Super) { this.emitJavascript(dotNode, TypeScript.TokenID.OpenParen, false); this.writeToOutput(".call("); this.emitThis(); if(callEx.arguments && callEx.arguments.members.length > 0) { this.writeToOutput(", "); this.emitJavascriptList(callEx.arguments, ", ", TypeScript.TokenID.Comma, false, false, false); } this.writeToOutput(")"); return true; } } return false; }; Emitter.prototype.emitThis = function () { if(this.thisFnc && !this.thisFnc.isMethod() && (!this.thisFnc.isConstructor)) { this.writeToOutput("_this"); } else { this.writeToOutput("this"); } }; Emitter.shouldCaptureThis = function shouldCaptureThis(func) { return func.hasSelfReference() || func.hasSuperReferenceInFatArrowFunction(); } Emitter.prototype.createFile = function (fileName, useUTF8) { try { return this.emitOptions.ioHost.createFile(fileName, useUTF8); } catch (ex) { this.errorReporter.emitterError(null, ex.message); } }; return Emitter; })(); TypeScript.Emitter = Emitter; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var ErrorReporter = (function () { function ErrorReporter(outfile) { this.outfile = outfile; this.parser = null; this.checker = null; this.lineCol = { line: 0, col: 0 }; this.emitAsComments = true; this.hasErrors = false; this.pushToErrorSink = false; this.errorSink = []; } ErrorReporter.prototype.getCapturedErrors = function () { return this.errorSink; }; ErrorReporter.prototype.freeCapturedErrors = function () { this.errorSink = []; }; ErrorReporter.prototype.captureError = function (emsg) { this.errorSink[this.errorSink.length] = emsg; }; ErrorReporter.prototype.setErrOut = function (outerr) { this.outfile = outerr; this.emitAsComments = false; }; ErrorReporter.prototype.emitPrefix = function () { if(this.emitAsComments) { this.outfile.Write("// "); } this.outfile.Write(this.checker.locationInfo.filename + "(" + this.lineCol.line + "," + this.lineCol.col + "): "); }; ErrorReporter.prototype.writePrefix = function (ast) { if(ast) { this.setError(ast); } else { this.lineCol.line = 0; this.lineCol.col = 0; } this.emitPrefix(); }; ErrorReporter.prototype.writePrefixFromSym = function (symbol) { if(symbol && this.checker.locationInfo.lineMap) { TypeScript.getSourceLineColFromMap(this.lineCol, symbol.location, this.checker.locationInfo.lineMap); } else { this.lineCol.line = -1; this.lineCol.col = -1; } this.emitPrefix(); }; ErrorReporter.prototype.setError = function (ast) { if(ast) { ast.flags |= TypeScript.ASTFlags.Error; if(this.checker.locationInfo.lineMap) { TypeScript.getSourceLineColFromMap(this.lineCol, ast.minChar, this.checker.locationInfo.lineMap); } } }; ErrorReporter.prototype.reportError = function (ast, message) { if(this.pushToErrorSink) { this.captureError(message); return; } this.hasErrors = true; if(ast && this.parser.errorRecovery && this.parser.errorCallback) { var len = (ast.limChar - ast.minChar); this.parser.errorCallback(ast.minChar, len, message, this.checker.locationInfo.unitIndex); } else { this.writePrefix(ast); this.outfile.WriteLine(message); } }; ErrorReporter.prototype.reportErrorFromSym = function (symbol, message) { if(this.pushToErrorSink) { this.captureError(message); return; } this.hasErrors = true; if(this.parser.errorRecovery && this.parser.errorCallback) { this.parser.errorCallback(symbol.location, symbol.length, message, this.checker.locationInfo.unitIndex); } else { this.writePrefixFromSym(symbol); this.outfile.WriteLine(message); } }; ErrorReporter.prototype.emitterError = function (ast, message) { this.reportError(ast, message); throw Error("EmitError"); }; ErrorReporter.prototype.duplicateIdentifier = function (ast, name) { this.reportError(ast, "Duplicate identifier '" + name + "'"); }; ErrorReporter.prototype.showRef = function (ast, text, symbol) { var defLineCol = { line: -1, col: -1 }; this.parser.getSourceLineCol(defLineCol, symbol.location); this.reportError(ast, "symbol " + text + " defined at (" + defLineCol.line + "," + defLineCol.col + ")"); }; ErrorReporter.prototype.unresolvedSymbol = function (ast, name) { this.reportError(ast, "The name '" + name + "' does not exist in the current scope"); }; ErrorReporter.prototype.symbolDoesNotReferToAValue = function (ast, name) { this.reportError(ast, "The name '" + name + "' does not refer to a value"); }; ErrorReporter.prototype.styleError = function (ast, msg) { var bkThrow = this.pushToErrorSink; this.pushToErrorSink = false; this.reportError(ast, "STYLE: " + msg); this.pushToErrorSink = bkThrow; }; ErrorReporter.prototype.simpleError = function (ast, msg) { this.reportError(ast, msg); }; ErrorReporter.prototype.simpleErrorFromSym = function (sym, msg) { this.reportErrorFromSym(sym, msg); }; ErrorReporter.prototype.invalidSuperReference = function (ast) { this.simpleError(ast, "Keyword 'super' can only be used inside a class instance method"); }; ErrorReporter.prototype.valueCannotBeModified = function (ast) { this.simpleError(ast, "The left-hand side of an assignment expression must be a variable, property or indexer"); }; ErrorReporter.prototype.invalidCall = function (ast, nodeType, scope) { var targetType = ast.target.type; var typeName = targetType.getScopedTypeName(scope); if(targetType.construct && (nodeType == TypeScript.NodeType.Call)) { this.reportError(ast, "Value of type '" + typeName + "' is not callable. Did you mean to include 'new'?"); } else { var catString = (nodeType == TypeScript.NodeType.Call) ? "callable" : "newable"; this.reportError(ast, "Value of type '" + typeName + "' is not " + catString); } }; ErrorReporter.prototype.indexLHS = function (ast, scope) { var targetType = ast.operand1.type.getScopedTypeName(scope); var indexType = ast.operand2.type.getScopedTypeName(scope); this.simpleError(ast, "Value of type '" + targetType + "' is not indexable by type '" + indexType + "'"); }; ErrorReporter.prototype.incompatibleTypes = function (ast, t1, t2, op, scope, comparisonInfo) { if(!t1) { t1 = this.checker.anyType; } if(!t2) { t2 = this.checker.anyType; } var reason = comparisonInfo ? comparisonInfo.message : ""; if(op) { this.reportError(ast, "Operator '" + op + "' cannot be applied to types '" + t1.getScopedTypeName(scope) + "' and '" + t2.getScopedTypeName(scope) + "'" + (reason ? ": " + reason : "")); } else { this.reportError(ast, "Cannot convert '" + t1.getScopedTypeName(scope) + "' to '" + t2.getScopedTypeName(scope) + "'" + (reason ? ": " + reason : "")); } }; ErrorReporter.prototype.expectedClassOrInterface = function (ast) { this.simpleError(ast, "Expected var, class, interface, or module"); }; ErrorReporter.prototype.unaryOperatorTypeError = function (ast, op, type) { this.reportError(ast, "Operator '" + op + "' cannot be applied to type '" + type.getTypeName() + "'"); }; return ErrorReporter; })(); TypeScript.ErrorReporter = ErrorReporter; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { (function (TypeContext) { TypeContext._map = []; TypeContext.NoTypes = 0; TypeContext.ArraySuffix = 1; TypeContext.Primitive = 2; TypeContext.Named = 4; TypeContext.AllSimpleTypes = TypeContext.Primitive | TypeContext.Named; TypeContext.AllTypes = TypeContext.Primitive | TypeContext.Named | TypeContext.ArraySuffix; })(TypeScript.TypeContext || (TypeScript.TypeContext = {})); var TypeContext = TypeScript.TypeContext; (function (ParseState) { ParseState._map = []; ParseState._map[0] = "None"; ParseState.None = 0; ParseState._map[1] = "StartScript"; ParseState.StartScript = 1; ParseState._map[2] = "StartStatementList"; ParseState.StartStatementList = 2; ParseState._map[3] = "StartStatement"; ParseState.StartStatement = 3; ParseState._map[4] = "StartFncDecl"; ParseState.StartFncDecl = 4; ParseState._map[5] = "FncDeclName"; ParseState.FncDeclName = 5; ParseState._map[6] = "FncDeclArgs"; ParseState.FncDeclArgs = 6; ParseState._map[7] = "FncDeclReturnType"; ParseState.FncDeclReturnType = 7; ParseState._map[8] = "ForInit"; ParseState.ForInit = 8; ParseState._map[9] = "ForInitAfterVar"; ParseState.ForInitAfterVar = 9; ParseState._map[10] = "ForCondStart"; ParseState.ForCondStart = 10; ParseState._map[11] = "EndStmtList"; ParseState.EndStmtList = 11; ParseState._map[12] = "EndScript"; ParseState.EndScript = 12; })(TypeScript.ParseState || (TypeScript.ParseState = {})); var ParseState = TypeScript.ParseState; var QuickParseResult = (function () { function QuickParseResult(Script, endLexState) { this.Script = Script; this.endLexState = endLexState; } return QuickParseResult; })(); TypeScript.QuickParseResult = QuickParseResult; var Parser = (function () { function Parser() { this.varLists = []; this.scopeLists = []; this.staticsLists = []; this.scanner = new TypeScript.Scanner(); this.currentToken = null; this.needTerminator = false; this.inFunction = false; this.inInterfaceDecl = false; this.currentClassDecl = null; this.inFncDecl = false; this.anonId = new TypeScript.Identifier("_anonymous"); this.style_requireSemi = false; this.style_funcInLoop = true; this.incremental = false; this.errorRecovery = false; this.outfile = undefined; this.errorCallback = null; this.state = ParseState.StartStatementList; this.ambientModule = false; this.ambientClass = false; this.topLevel = true; this.allowImportDeclaration = true; this.currentUnitIndex = (-1); this.prevIDTok = null; this.statementInfoStack = new Array(); this.hasTopLevelImportOrExport = false; this.strictMode = false; this.nestingLevel = 0; this.prevExpr = null; this.currentClassDefinition = null; this.parsingClassConstructorDefinition = false; this.parsingDeclareFile = false; this.amdDependencies = []; this.inferPropertiesFromThisAssignment = false; this.requiresExtendsBlock = false; this.fname = ""; } Parser.prototype.resetStmtStack = function () { this.statementInfoStack = new Array(); }; Parser.prototype.inLoop = function () { for(var j = this.statementInfoStack.length - 1; j >= 0; j--) { if(this.statementInfoStack[j].stmt.isLoop()) { return true; } } return false; }; Parser.prototype.pushStmt = function (stmt, labels) { var info = { stmt: stmt, labels: labels }; this.statementInfoStack.push(info); }; Parser.prototype.popStmt = function () { return this.statementInfoStack.pop(); }; Parser.prototype.resolveJumpTarget = function (jump) { var resolvedTarget = TypeScript.AST.getResolvedIdentifierName(jump.target); var len = this.statementInfoStack.length; for(var i = len - 1; i >= 0; i--) { var info = this.statementInfoStack[i]; if(jump.target) { if(info.labels && (info.labels.members.length > 0)) { for(var j = 0, labLen = info.labels.members.length; j < labLen; j++) { var label = info.labels.members[j]; if(label.id.text == resolvedTarget) { jump.setResolvedTarget(this, info.stmt); return; } } } } else { if(info.stmt.isLoop()) { jump.setResolvedTarget(this, info.stmt); return; } else { if((info.stmt.nodeType == TypeScript.NodeType.Switch) && (jump.nodeType == TypeScript.NodeType.Break)) { jump.setResolvedTarget(this, info.stmt); return; } } } } if(jump.target) { this.reportParseError("could not find enclosing statement with label " + jump.target); } else { if(jump.nodeType == TypeScript.NodeType.Break) { this.reportParseError("break statement requires enclosing loop or switch"); } else { this.reportParseError("continue statement requires enclosing loop"); } } }; Parser.prototype.setErrorRecovery = function (outfile) { this.outfile = outfile; this.errorRecovery = true; }; Parser.prototype.getSourceLineCol = function (lineCol, minChar) { TypeScript.getSourceLineColFromMap(lineCol, minChar, this.scanner.lineMap); }; Parser.prototype.createRef = function (text, hasEscapeSequence, minChar) { var id = new TypeScript.Identifier(text, hasEscapeSequence); id.minChar = minChar; return id; }; Parser.prototype.reportParseStyleError = function (message) { this.reportParseError("STYLE: " + message); }; Parser.prototype.reportParseError = function (message, startPos, pos) { if (typeof startPos === "undefined") { startPos = this.scanner.startPos; } if (typeof pos === "undefined") { pos = this.scanner.pos; } var len = Math.max(1, pos - startPos); if(this.errorCallback) { this.errorCallback(startPos, len, message, this.currentUnitIndex); } else { if(this.errorRecovery) { var lineCol = { line: -1, col: -1 }; this.getSourceLineCol(lineCol, startPos); if(this.outfile) { this.outfile.WriteLine("// " + this.fname + " (" + lineCol.line + "," + lineCol.col + "): " + message); } } else { throw new SyntaxError(this.fname + " (" + this.scanner.line + "," + this.scanner.col + "): " + message); } } }; Parser.prototype.checkNextToken = function (tokenId, errorRecoverySet, errorText) { if (typeof errorText === "undefined") { errorText = null; } this.currentToken = this.scanner.scan(); this.checkCurrentToken(tokenId, errorRecoverySet, errorText); }; Parser.prototype.skip = function (errorRecoverySet) { errorRecoverySet |= TypeScript.ErrorRecoverySet.EOF; var ersTok = TypeScript.ErrorRecoverySet.None; var tokenInfo = TypeScript.lookupToken(this.currentToken.tokenId); if(tokenInfo != undefined) { ersTok = tokenInfo.ers; } var pendingRightCurlies = 0; while(((ersTok & errorRecoverySet) == TypeScript.ErrorRecoverySet.None) || (this.currentToken.tokenId == TypeScript.TokenID.CloseBrace) && (pendingRightCurlies > 0)) { if(this.currentToken.tokenId == TypeScript.TokenID.OpenBrace) { pendingRightCurlies++; } else { if(this.currentToken.tokenId == TypeScript.TokenID.CloseBrace) { pendingRightCurlies--; } } this.currentToken = this.scanner.scan(); ersTok = TypeScript.ErrorRecoverySet.None; tokenInfo = TypeScript.lookupToken(this.currentToken.tokenId); if(tokenInfo != undefined) { ersTok = tokenInfo.ers; } } }; Parser.prototype.checkCurrentToken = function (tokenId, errorRecoverySet, errorText) { if (typeof errorText === "undefined") { errorText = null; } if(this.currentToken.tokenId != tokenId) { errorText = errorText == null ? ("Expected '" + TypeScript.tokenTable[tokenId].text + "'") : errorText; this.reportParseError(errorText); if(this.errorRecovery) { this.skip(errorRecoverySet); } } else { this.currentToken = this.scanner.scan(); } }; Parser.prototype.pushDeclLists = function () { this.staticsLists.push(new TypeScript.ASTList()); this.varLists.push(new TypeScript.ASTList()); this.scopeLists.push(new TypeScript.ASTList()); }; Parser.prototype.popDeclLists = function () { this.staticsLists.pop(); this.varLists.pop(); this.scopeLists.pop(); }; Parser.prototype.topVarList = function () { return this.varLists[this.varLists.length - 1]; }; Parser.prototype.topScopeList = function () { return this.scopeLists[this.scopeLists.length - 1]; }; Parser.prototype.topStaticsList = function () { return this.staticsLists[this.staticsLists.length - 1]; }; Parser.prototype.parseComment = function (comment) { if(comment) { var c = new TypeScript.Comment(comment.value, comment.isBlock, comment.endsLine); c.minChar = comment.startPos; c.limChar = comment.startPos + comment.value.length; var lineCol = { line: -1, col: -1 }; this.getSourceLineCol(lineCol, c.minChar); c.minLine = lineCol.line; this.getSourceLineCol(lineCol, c.limChar); c.limLine = lineCol.line; if(!comment.isBlock && comment.value.length > 3 && comment.value.substring(0, 3) == "///") { var dependencyPath = TypeScript.getAdditionalDependencyPath(comment.value); if(dependencyPath) { this.amdDependencies.push(dependencyPath); } if(TypeScript.getImplicitImport(comment.value)) { this.hasTopLevelImportOrExport = true; } } return c; } else { return null; } }; Parser.prototype.parseCommentsInner = function (comments) { if(comments) { var commentASTs = new Array(); for(var i = 0; i < comments.length; i++) { commentASTs.push(this.parseComment(comments[i])); } return commentASTs; } else { return null; } }; Parser.prototype.parseComments = function () { var comments = this.scanner.getComments(); return this.parseCommentsInner(comments); }; Parser.prototype.parseCommentsForLine = function (line) { var comments = this.scanner.getCommentsForLine(line); return this.parseCommentsInner(comments); }; Parser.prototype.combineComments = function (comment1, comment2) { if(comment1 == null) { return comment2; } else { if(comment2 == null) { return comment1; } else { return comment1.concat(comment2); } } }; Parser.prototype.parseEnumDecl = function (errorRecoverySet, modifiers) { var leftCurlyCount = this.scanner.leftCurlyCount; var rightCurlyCount = this.scanner.rightCurlyCount; var name = null; if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { name = TypeScript.Identifier.fromToken(this.currentToken); name.minChar = this.scanner.startPos; name.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); } else { this.reportParseError("Enum declaration requires identifier"); if(this.errorRecovery) { name = new TypeScript.MissingIdentifier(); name.minChar = this.scanner.startPos; name.limChar = this.scanner.startPos; name.flags |= TypeScript.ASTFlags.Error; } } var membersMinChar = this.scanner.startPos; this.checkCurrentToken(TypeScript.TokenID.OpenBrace, errorRecoverySet | TypeScript.ErrorRecoverySet.ID); this.pushDeclLists(); var members = new TypeScript.ASTList(); members.minChar = membersMinChar; var mapDecl = new TypeScript.VarDecl(new TypeScript.Identifier("_map"), 0); mapDecl.varFlags |= TypeScript.VarFlags.Exported; mapDecl.varFlags |= TypeScript.VarFlags.Private; mapDecl.varFlags |= (TypeScript.VarFlags.Property | TypeScript.VarFlags.Public); mapDecl.init = new TypeScript.UnaryExpression(TypeScript.NodeType.ArrayLit, null); members.append(mapDecl); var lastValue = null; for(; ; ) { var minChar = this.scanner.startPos; var limChar; var memberName = null; var memberValue = null; var preComments = null; var postComments = null; if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToIDName(this.currentToken)) { memberName = TypeScript.Identifier.fromToken(this.currentToken); memberName.minChar = this.scanner.startPos; memberName.limChar = this.scanner.pos; } else { if(this.currentToken.tokenId == TypeScript.TokenID.CloseBrace) { break; } else { this.reportParseError("Expected identifer of enum member"); if(this.errorRecovery) { memberName = new TypeScript.MissingIdentifier(); memberName.minChar = this.scanner.startPos; memberName.limChar = this.scanner.startPos; memberName.flags |= TypeScript.ASTFlags.Error; } } } limChar = this.scanner.pos; preComments = this.parseComments(); this.currentToken = this.scanner.scan(); postComments = this.parseComments(); if(this.currentToken.tokenId == TypeScript.TokenID.Equals) { this.currentToken = this.scanner.scan(); memberValue = this.parseExpr(errorRecoverySet, TypeScript.OperatorPrecedence.Comma, true, TypeContext.NoTypes); lastValue = memberValue; limChar = memberValue.limChar; } else { if(lastValue == null) { memberValue = new TypeScript.NumberLiteral(0); lastValue = memberValue; } else { memberValue = new TypeScript.NumberLiteral(lastValue.value + 1); lastValue = memberValue; } var map = new TypeScript.BinaryExpression(TypeScript.NodeType.Asg, new TypeScript.BinaryExpression(TypeScript.NodeType.Index, new TypeScript.Identifier("_map"), memberValue), new TypeScript.StringLiteral('"' + memberName.actualText + '"')); members.append(map); } var member = new TypeScript.VarDecl(memberName, this.nestingLevel); member.minChar = minChar; member.limChar = limChar; member.init = memberValue; member.typeExpr = new TypeScript.TypeReference(this.createRef(name.actualText, name.hasEscapeSequence, -1), 0); member.varFlags |= (TypeScript.VarFlags.Readonly | TypeScript.VarFlags.Property); if(memberValue.nodeType == TypeScript.NodeType.NumberLit) { member.varFlags |= TypeScript.VarFlags.Constant; } member.preComments = preComments; members.append(member); member.postComments = postComments; member.varFlags |= TypeScript.VarFlags.Exported; if(this.currentToken.tokenId == TypeScript.TokenID.Comma) { this.currentToken = this.scanner.scan(); member.postComments = this.combineComments(member.postComments, this.parseCommentsForLine(this.scanner.prevLine)); if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || (TypeScript.convertTokToIDName(this.currentToken))) { continue; } } break; } var endingToken = new TypeScript.ASTSpan(); endingToken.minChar = this.scanner.startPos; endingToken.limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseBrace, errorRecoverySet); members.limChar = this.scanner.lastTokenLimChar(); var modDecl = new TypeScript.ModuleDeclaration(name, members, this.topVarList(), this.topScopeList(), endingToken); modDecl.modFlags |= TypeScript.ModuleFlags.IsEnum; this.popDeclLists(); modDecl.leftCurlyCount = this.scanner.leftCurlyCount - leftCurlyCount; modDecl.rightCurlyCount = this.scanner.rightCurlyCount - rightCurlyCount; return modDecl; }; Parser.prototype.parseDottedName = function (enclosedList) { this.currentToken = this.scanner.scan(); if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { var id = TypeScript.Identifier.fromToken(this.currentToken); id.preComments = this.parseComments(); enclosedList[enclosedList.length] = id; id.minChar = this.scanner.startPos; id.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.Dot) { this.parseDottedName(enclosedList); } } else { this.reportParseError("need identifier after '.'"); } }; Parser.prototype.isValidImportPath = function (importPath) { importPath = TypeScript.stripQuotes(importPath); if(!importPath || importPath.indexOf(':') != -1 || importPath.indexOf('\\') != -1 || importPath.charAt(0) == '/') { return false; } return true; }; Parser.prototype.parseImportDeclaration = function (errorRecoverySet, modifiers) { var name = null; var alias = null; var importDecl = null; var minChar = this.scanner.startPos; var isDynamicImport = false; this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.Identifier || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { name = TypeScript.Identifier.fromToken(this.currentToken); } else { this.reportParseError("Expected identifer after 'import'"); name = new TypeScript.MissingIdentifier(); } name.minChar = this.scanner.startPos; name.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); this.checkCurrentToken(TypeScript.TokenID.Equals, errorRecoverySet | TypeScript.ErrorRecoverySet.ID); var aliasPreComments = this.parseComments(); var limChar; if(this.currentToken.tokenId == TypeScript.TokenID.Identifier || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { if(this.currentToken.tokenId == TypeScript.TokenID.Module) { limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.OpenParen) { this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.StringLiteral || this.currentToken.tokenId == TypeScript.TokenID.Identifier || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { if(this.currentToken.tokenId == TypeScript.TokenID.StringLiteral) { if(this.topLevel) { this.hasTopLevelImportOrExport = true; } else { if(!this.allowImportDeclaration) { this.reportParseError("Import declaration of external module is permitted only in global or top level dynamic modules"); } } var aliasText = this.currentToken.getText(); alias = TypeScript.Identifier.fromToken(this.currentToken); alias.minChar = this.scanner.startPos; alias.limChar = this.scanner.pos; if(!this.isValidImportPath((alias).text)) { this.reportParseError("Invalid import path"); } isDynamicImport = true; this.currentToken = this.scanner.scan(); alias.preComments = aliasPreComments; } else { alias = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon, TypeScript.OperatorPrecedence.Assignment, true, TypeContext.NoTypes); alias.preComments = aliasPreComments; } } limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet | TypeScript.ErrorRecoverySet.ID); if(alias) { alias.postComments = this.parseComments(); } } } else { alias = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon, TypeScript.OperatorPrecedence.Assignment, true, TypeContext.NoTypes); limChar = this.scanner.pos; } } else { this.reportParseError("Expected module name"); alias = new TypeScript.MissingIdentifier(); alias.minChar = this.scanner.startPos; if(this.currentToken.tokenId == TypeScript.TokenID.Semicolon) { alias.limChar = this.scanner.startPos; } else { alias.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); } alias.flags |= TypeScript.ASTFlags.Error; limChar = alias.limChar; } importDecl = new TypeScript.ImportDeclaration(name, alias); importDecl.isDynamicImport = isDynamicImport; importDecl.minChar = minChar; importDecl.limChar = limChar; return importDecl; }; Parser.prototype.parseModuleDecl = function (errorRecoverySet, modifiers, preComments) { var leftCurlyCount = this.scanner.leftCurlyCount; var rightCurlyCount = this.scanner.rightCurlyCount; var svAmbient = this.ambientModule; var svTopLevel = this.topLevel; this.topLevel = false; if(this.parsingDeclareFile || svAmbient || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)) { this.ambientModule = true; } this.currentToken = this.scanner.scan(); var name = null; var enclosedList = null; this.pushDeclLists(); var minChar = this.scanner.startPos; var isDynamicMod = false; if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || (this.currentToken.tokenId == TypeScript.TokenID.StringLiteral) || (!TypeScript.isPrimitiveTypeToken(this.currentToken) && TypeScript.convertTokToID(this.currentToken, this.strictMode))) { var nameText = this.currentToken.getText(); if(this.currentToken.tokenId == TypeScript.TokenID.StringLiteral) { isDynamicMod = true; if(!this.ambientModule) { this.reportParseError("Only ambient dynamic modules may have string literal names"); } if(!svTopLevel) { this.reportParseError("Dynamic modules may not be nested within other modules"); } } name = TypeScript.Identifier.fromToken(this.currentToken); name.minChar = this.scanner.startPos; name.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); } else { if(this.currentToken.tokenId == TypeScript.TokenID.OpenBrace) { this.reportParseError("Module name missing"); name = new TypeScript.Identifier(""); name.minChar = minChar; name.limChar = minChar; } } if(this.currentToken.tokenId == TypeScript.TokenID.Dot) { enclosedList = new Array(); this.parseDottedName(enclosedList); } if(name == null) { name = new TypeScript.MissingIdentifier(); } var moduleBody = new TypeScript.ASTList(); var bodyMinChar = this.scanner.startPos; this.checkCurrentToken(TypeScript.TokenID.OpenBrace, errorRecoverySet | TypeScript.ErrorRecoverySet.ID); if(svTopLevel && isDynamicMod) { this.allowImportDeclaration = true; } else { this.allowImportDeclaration = false; } this.parseStatementList(errorRecoverySet | TypeScript.ErrorRecoverySet.RCurly, moduleBody, true, true, TypeScript.AllowedElements.Global, modifiers); moduleBody.minChar = bodyMinChar; moduleBody.limChar = this.scanner.pos; var endingToken = new TypeScript.ASTSpan(); endingToken.minChar = this.scanner.startPos; endingToken.limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseBrace, errorRecoverySet); var limChar = this.scanner.lastTokenLimChar(); var moduleDecl; this.allowImportDeclaration = svTopLevel; if(enclosedList && (enclosedList.length > 0)) { var len = enclosedList.length; var innerName = enclosedList[len - 1]; var innerDecl = new TypeScript.ModuleDeclaration(innerName, moduleBody, this.topVarList(), this.topScopeList(), endingToken); innerDecl.preComments = preComments; if(this.parsingDeclareFile || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)) { innerDecl.modFlags |= TypeScript.ModuleFlags.Ambient; } innerDecl.modFlags |= TypeScript.ModuleFlags.Exported; innerDecl.minChar = minChar; innerDecl.limChar = limChar; this.popDeclLists(); var outerModBod; for(var i = len - 2; i >= 0; i--) { outerModBod = new TypeScript.ASTList(); outerModBod.append(innerDecl); innerName = enclosedList[i]; innerDecl = new TypeScript.ModuleDeclaration(innerName, outerModBod, new TypeScript.ASTList(), new TypeScript.ASTList(), endingToken); outerModBod.minChar = innerDecl.minChar = minChar; outerModBod.limChar = innerDecl.limChar = limChar; if(this.parsingDeclareFile || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)) { innerDecl.modFlags |= TypeScript.ModuleFlags.Ambient; } innerDecl.modFlags |= TypeScript.ModuleFlags.Exported; } outerModBod = new TypeScript.ASTList(); outerModBod.append(innerDecl); outerModBod.minChar = minChar; outerModBod.limChar = limChar; moduleDecl = new TypeScript.ModuleDeclaration(name, outerModBod, new TypeScript.ASTList(), new TypeScript.ASTList(), endingToken); } else { moduleDecl = new TypeScript.ModuleDeclaration(name, moduleBody, this.topVarList(), this.topScopeList(), endingToken); moduleDecl.preComments = preComments; this.popDeclLists(); } if(this.parsingDeclareFile || svAmbient || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)) { moduleDecl.modFlags |= TypeScript.ModuleFlags.Ambient; } if(svAmbient || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported)) { moduleDecl.modFlags |= TypeScript.ModuleFlags.Exported; } if(isDynamicMod) { moduleDecl.modFlags |= TypeScript.ModuleFlags.IsDynamic; } this.ambientModule = svAmbient; this.topLevel = svTopLevel; moduleDecl.leftCurlyCount = this.scanner.leftCurlyCount - leftCurlyCount; moduleDecl.rightCurlyCount = this.scanner.rightCurlyCount - rightCurlyCount; moduleDecl.limChar = moduleBody.limChar; return moduleDecl; }; Parser.prototype.parseTypeReferenceTail = function (errorRecoverySet, minChar, term) { var result = new TypeScript.TypeReference(term, 0); result.minChar = minChar; while(this.currentToken.tokenId == TypeScript.TokenID.OpenBracket) { this.currentToken = this.scanner.scan(); result.arrayCount++; this.checkCurrentToken(TypeScript.TokenID.CloseBracket, errorRecoverySet | TypeScript.ErrorRecoverySet.LBrack); } result.limChar = this.scanner.lastTokenLimChar(); return result; }; Parser.prototype.parseNamedType = function (errorRecoverySet, minChar, term, tail) { this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.Dot) { var curpos = this.scanner.pos; this.currentToken = this.scanner.scan(); if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || ((!this.errorRecovery || !this.scanner.lastTokenHadNewline()) && TypeScript.convertTokToID(this.currentToken, this.strictMode))) { var op2 = TypeScript.Identifier.fromToken(this.currentToken); op2.minChar = this.scanner.startPos; op2.limChar = this.scanner.pos; var dotNode = new TypeScript.BinaryExpression(TypeScript.NodeType.Dot, term, op2); dotNode.minChar = term.minChar; dotNode.limChar = op2.limChar; return this.parseNamedType(errorRecoverySet, minChar, dotNode, tail); } else { this.reportParseError("need identifier after '.'"); if(this.errorRecovery) { term.flags |= TypeScript.ASTFlags.DotLHS; term.limChar = this.scanner.lastTokenLimChar(); return term; } else { var eop2 = new TypeScript.MissingIdentifier(); eop2.minChar = this.scanner.pos; eop2.limChar = this.scanner.pos; var edotNode = new TypeScript.BinaryExpression(TypeScript.NodeType.Dot, term, eop2); edotNode.flags |= TypeScript.ASTFlags.Error; edotNode.minChar = term.minChar; edotNode.limChar = eop2.limChar; return this.parseNamedType(errorRecoverySet, minChar, edotNode, tail); } } } else { if(tail) { return this.parseTypeReferenceTail(errorRecoverySet, minChar, term); } else { return term; } } }; Parser.prototype.parseTypeReference = function (errorRecoverySet, allowVoid) { var minChar = this.scanner.startPos; var isConstructorMember = false; switch(this.currentToken.tokenId) { case TypeScript.TokenID.Void: { if(!allowVoid) { this.reportParseError("void not a valid type in this context"); } } case TypeScript.TokenID.Any: case TypeScript.TokenID.Number: case TypeScript.TokenID.Bool: case TypeScript.TokenID.String: { var text = TypeScript.tokenTable[this.currentToken.tokenId].text; var predefinedIdentifier = new TypeScript.Identifier(text); predefinedIdentifier.minChar = minChar; predefinedIdentifier.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); return this.parseTypeReferenceTail(errorRecoverySet, minChar, predefinedIdentifier); } case TypeScript.TokenID.Identifier: { var ident = this.createRef(this.currentToken.getText(), (this.currentToken).hasEscapeSequence, minChar); ident.limChar = this.scanner.pos; return this.parseNamedType(errorRecoverySet, minChar, ident, true); } case TypeScript.TokenID.OpenBrace: { return this.parseObjectType(minChar, errorRecoverySet); } case TypeScript.TokenID.New: { this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId != TypeScript.TokenID.OpenParen) { this.reportParseError("Expected '('"); } else { isConstructorMember = true; } } case TypeScript.TokenID.OpenParen: { var formals = new TypeScript.ASTList(); var variableArgList = this.parseFormalParameterList(errorRecoverySet | TypeScript.ErrorRecoverySet.RParen, formals, false, true, false, false, false, false, null, true); this.checkCurrentToken(TypeScript.TokenID.EqualsGreaterThan, errorRecoverySet); var returnType = this.parseTypeReference(errorRecoverySet, true); var funcDecl = new TypeScript.FuncDecl(null, null, false, formals, null, null, null, TypeScript.NodeType.FuncDecl); funcDecl.returnTypeAnnotation = returnType; funcDecl.variableArgList = variableArgList; funcDecl.fncFlags |= TypeScript.FncFlags.Signature; if(isConstructorMember) { funcDecl.fncFlags |= TypeScript.FncFlags.ConstructMember; funcDecl.hint = "_construct"; funcDecl.classDecl = null; } funcDecl.minChar = minChar; return this.parseTypeReferenceTail(errorRecoverySet, minChar, funcDecl); } default: { this.reportParseError("Expected type name"); var etr = new TypeScript.TypeReference(null, 0); etr.flags |= TypeScript.ASTFlags.Error; etr.minChar = this.scanner.pos; etr.limChar = this.scanner.pos; return etr; } } }; Parser.prototype.parseObjectType = function (minChar, errorRecoverySet) { this.currentToken = this.scanner.scan(); var members = new TypeScript.ASTList(); members.minChar = minChar; var prevInInterfaceDecl = this.inInterfaceDecl; this.inInterfaceDecl = true; this.parseTypeMemberList(errorRecoverySet | TypeScript.ErrorRecoverySet.RCurly, members); this.inInterfaceDecl = prevInInterfaceDecl; this.checkCurrentToken(TypeScript.TokenID.CloseBrace, errorRecoverySet); var interfaceDecl = new TypeScript.InterfaceDeclaration(this.anonId, members, null, null); interfaceDecl.minChar = minChar; interfaceDecl.limChar = members.limChar; return this.parseTypeReferenceTail(errorRecoverySet, minChar, interfaceDecl); }; Parser.prototype.parseFunctionBlock = function (errorRecoverySet, allowedElements, parentModifiers, bod, bodMinChar) { this.state = ParseState.StartStatementList; this.checkCurrentToken(TypeScript.TokenID.OpenBrace, errorRecoverySet | TypeScript.ErrorRecoverySet.StmtStart); var savedInFunction = this.inFunction; this.inFunction = true; this.parseStatementList(errorRecoverySet | TypeScript.ErrorRecoverySet.RCurly | TypeScript.ErrorRecoverySet.StmtStart, bod, true, false, allowedElements, parentModifiers); bod.minChar = bodMinChar; bod.limChar = this.scanner.pos; this.inFunction = savedInFunction; var ec = new TypeScript.EndCode(); ec.minChar = bod.limChar; ec.limChar = ec.minChar; bod.append(ec); }; Parser.prototype.parseFunctionStatements = function (errorRecoverySet, name, isConstructor, isMethod, args, allowedElements, minChar, requiresSignature, parentModifiers) { this.pushDeclLists(); var svStmtStack = this.statementInfoStack; this.resetStmtStack(); var bod = null; var wasShorthand = false; var isAnonLambda = false; var limChar; if(requiresSignature) { limChar = this.scanner.pos; if(this.currentToken.tokenId === TypeScript.TokenID.OpenBrace) { this.reportParseError("Function declarations are not permitted within interfaces, ambient modules or classes"); bod = new TypeScript.ASTList(); var bodMinChar = this.scanner.startPos; this.parseFunctionBlock(errorRecoverySet, allowedElements, parentModifiers, bod, bodMinChar); this.checkCurrentToken(TypeScript.TokenID.CloseBrace, errorRecoverySet); if(this.currentToken.tokenId === TypeScript.TokenID.Semicolon) { this.currentToken = this.scanner.scan(); } } else { this.checkCurrentToken(TypeScript.TokenID.Semicolon, errorRecoverySet, "Expected ';'"); } } else { bod = new TypeScript.ASTList(); var bodMinChar = this.scanner.startPos; if(this.currentToken.tokenId == TypeScript.TokenID.EqualsGreaterThan) { if(isMethod) { this.reportParseError("'=>' may not be used for class methods"); } wasShorthand = true; this.currentToken = this.scanner.scan(); } if(wasShorthand && this.currentToken.tokenId != TypeScript.TokenID.OpenBrace) { var retExpr = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon, TypeScript.OperatorPrecedence.Assignment, true, TypeContext.NoTypes); var retStmt = new TypeScript.ReturnStatement(); retStmt.returnExpression = retExpr; retStmt.minChar = retExpr.minChar; retStmt.limChar = retExpr.limChar; bod.minChar = bodMinChar; bod.append(retStmt); } else { isAnonLambda = wasShorthand; this.parseFunctionBlock(errorRecoverySet, allowedElements, parentModifiers, bod, bodMinChar); } limChar = this.scanner.pos; } var funcDecl = new TypeScript.FuncDecl(name, bod, isConstructor, args, this.topVarList(), this.topScopeList(), this.topStaticsList(), TypeScript.NodeType.FuncDecl); this.popDeclLists(); var scopeList = this.topScopeList(); scopeList.append(funcDecl); var staticFuncDecl = false; if(!requiresSignature) { if(!wasShorthand || isAnonLambda) { funcDecl.endingToken = new TypeScript.ASTSpan(); funcDecl.endingToken.minChar = this.scanner.startPos; funcDecl.endingToken.limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseBrace, errorRecoverySet); if(isAnonLambda) { funcDecl.fncFlags |= TypeScript.FncFlags.IsFatArrowFunction; } } else { funcDecl.fncFlags |= TypeScript.FncFlags.IsFatArrowFunction; funcDecl.endingToken = new TypeScript.ASTSpan(); funcDecl.endingToken.minChar = bod.members[0].minChar; funcDecl.endingToken.limChar = bod.members[0].limChar; } } funcDecl.minChar = minChar; funcDecl.limChar = limChar; if(!requiresSignature) { funcDecl.fncFlags |= TypeScript.FncFlags.Definition; } this.statementInfoStack = svStmtStack; return funcDecl; }; Parser.prototype.transformAnonymousArgsIntoFormals = function (formals, argList) { var _this = this; var translateBinExOperand = function (operand) { if(operand.nodeType == TypeScript.NodeType.Comma) { return _this.transformAnonymousArgsIntoFormals(formals, operand); } else { if(operand.nodeType == TypeScript.NodeType.Name || operand.nodeType == TypeScript.NodeType.Asg) { var opArg = operand.nodeType == TypeScript.NodeType.Asg ? (operand).operand1 : operand; var arg = new TypeScript.ArgDecl(opArg); arg.preComments = opArg.preComments; arg.postComments = opArg.postComments; arg.minChar = operand.minChar; arg.limChar = operand.limChar; if(TypeScript.hasFlag(opArg.flags, TypeScript.ASTFlags.PossibleOptionalParameter)) { arg.isOptional = true; } if(operand.nodeType == TypeScript.NodeType.Asg) { arg.init = (operand).operand2; } formals.append(arg); return arg.isOptional || arg.init; } else { _this.reportParseError("Invalid lambda argument"); } } return false; }; if(argList) { if(argList.nodeType == TypeScript.NodeType.Comma) { var commaList = argList; if(commaList.operand1.isParenthesized) { this.reportParseError("Invalid lambda argument", commaList.operand1.minChar, commaList.operand1.limChar); } if(commaList.operand2.isParenthesized) { this.reportParseError("Invalid lambda argument", commaList.operand2.minChar, commaList.operand2.limChar); } var isOptional = translateBinExOperand(commaList.operand1); isOptional = translateBinExOperand(commaList.operand2) || isOptional; return isOptional; } else { return translateBinExOperand(argList); } } }; Parser.prototype.parseFormalParameterList = function (errorRecoverySet, formals, isClassConstr, isSig, isIndexer, isGetter, isSetter, isLambda, preProcessedLambdaArgs, expectClosingRParen) { formals.minChar = this.scanner.startPos; if(isIndexer) { this.currentToken = this.scanner.scan(); } else { if(!isLambda) { this.checkCurrentToken(TypeScript.TokenID.OpenParen, errorRecoverySet | TypeScript.ErrorRecoverySet.RParen); } } var sawEllipsis = false; var firstArg = true; var hasOptional = false; var haveFirstArgID = false; if(isLambda && preProcessedLambdaArgs && preProcessedLambdaArgs.nodeType != TypeScript.NodeType.EmptyExpr) { hasOptional = this.transformAnonymousArgsIntoFormals(formals, preProcessedLambdaArgs); haveFirstArgID = true; } while(true) { var munchedArg = false; var argFlags = TypeScript.VarFlags.None; var argMinChar = this.scanner.startPos; if(this.inferPropertiesFromThisAssignment && this.currentToken.tokenId == TypeScript.TokenID.This) { if(!isClassConstr) { this.reportParseError("Instance property declarations using 'this' may only be used in class constructors"); } this.currentToken = this.scanner.scan(); argFlags |= (TypeScript.VarFlags.Public | TypeScript.VarFlags.Property); if(this.currentClassDefinition) { this.currentClassDefinition.varFlags |= TypeScript.VarFlags.ClassSuperMustBeFirstCallInConstructor; } } if(this.currentToken.tokenId == TypeScript.TokenID.Public) { argFlags |= (TypeScript.VarFlags.Public | TypeScript.VarFlags.Property); if(this.currentClassDefinition) { this.currentClassDefinition.varFlags |= TypeScript.VarFlags.ClassSuperMustBeFirstCallInConstructor; } } else { if(this.currentToken.tokenId == TypeScript.TokenID.Private) { argFlags |= (TypeScript.VarFlags.Private | TypeScript.VarFlags.Property); if(this.currentClassDefinition) { this.currentClassDefinition.varFlags |= TypeScript.VarFlags.ClassSuperMustBeFirstCallInConstructor; } } else { if(this.currentToken.tokenId == TypeScript.TokenID.Static && isClassConstr) { this.reportParseError("Static properties can not be declared as parameter properties"); this.currentToken = this.scanner.scan(); } } } if(argFlags != TypeScript.VarFlags.None) { if(!isClassConstr) { this.reportParseError("only constructor parameters can be properties"); } this.currentToken = this.scanner.scan(); if(TypeScript.isModifier(this.currentToken)) { this.reportParseError("Multiple modifiers may not be applied to parameters"); this.currentToken = this.scanner.scan(); } if(this.inferPropertiesFromThisAssignment && this.currentToken.tokenId == TypeScript.TokenID.This) { if(!isClassConstr) { this.reportParseError("Instance property declarations using 'this' may only be used in class constructors"); } this.currentToken = this.scanner.scan(); this.currentToken = this.scanner.scan(); } } else { if(this.currentToken.tokenId == TypeScript.TokenID.DotDotDot) { sawEllipsis = true; this.currentToken = this.scanner.scan(); if(!(this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { this.reportParseError("'...' parameters require both a parameter name and an array type annotation to be specified"); sawEllipsis = false; } } } var argId = null; if(!haveFirstArgID && (this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { argId = TypeScript.Identifier.fromToken(this.currentToken); argId.minChar = this.scanner.startPos; argId.limChar = this.scanner.pos; } if(haveFirstArgID || argId) { munchedArg = true; var type = null; var arg = null; if(haveFirstArgID && formals.members.length) { arg = formals.members[formals.members.length - 1]; if(arg.isOptional) { hasOptional = true; } } else { arg = new TypeScript.ArgDecl(argId); if(isGetter) { this.reportParseError("Property getters may not take any arguments"); } if(isSetter && !firstArg) { this.reportParseError("Property setters may only take one argument"); } arg.minChar = argMinChar; arg.preComments = this.parseComments(); this.currentToken = this.scanner.scan(); } if(this.currentToken.tokenId == TypeScript.TokenID.Question) { arg.isOptional = true; hasOptional = true; this.currentToken = this.scanner.scan(); } if(this.currentToken.tokenId == TypeScript.TokenID.Colon) { this.currentToken = this.scanner.scan(); type = this.parseTypeReference(errorRecoverySet, false); } if(this.currentToken.tokenId == TypeScript.TokenID.Equals) { if(isSig) { this.reportParseError("Arguments in signatures may not have default values"); } hasOptional = true; this.currentToken = this.scanner.scan(); arg.init = this.parseExpr(TypeScript.ErrorRecoverySet.Comma | errorRecoverySet, TypeScript.OperatorPrecedence.Comma, false, TypeContext.NoTypes); } if(hasOptional && !arg.isOptionalArg() && !sawEllipsis) { this.reportParseError("Optional parameters may only be followed by other optional parameters"); } if(sawEllipsis && arg.isOptionalArg()) { this.reportParseError("Varargs may not be optional or have default parameters"); } if(sawEllipsis && !type) { this.reportParseError("'...' parameters require both a parameter name and an array type annotation to be specified"); } arg.postComments = this.parseComments(); arg.typeExpr = type; arg.limChar = this.scanner.lastTokenLimChar(); arg.varFlags |= argFlags; if(!haveFirstArgID) { formals.append(arg); } else { haveFirstArgID = false; } } firstArg = false; if(this.currentToken.tokenId == TypeScript.TokenID.Comma) { if((munchedArg) && (!sawEllipsis)) { this.currentToken = this.scanner.scan(); continue; } else { this.reportParseError("Unexpected ',' in argument list"); if(this.errorRecovery) { this.currentToken = this.scanner.scan(); continue; } } } else { break; } } if(isIndexer) { this.checkCurrentToken(TypeScript.TokenID.CloseBracket, errorRecoverySet | TypeScript.ErrorRecoverySet.LCurly | TypeScript.ErrorRecoverySet.SColon); } else { if(expectClosingRParen) { this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet | TypeScript.ErrorRecoverySet.LCurly | TypeScript.ErrorRecoverySet.SColon); } } formals.limChar = this.scanner.lastTokenLimChar(); return sawEllipsis; }; Parser.prototype.parseFncDecl = function (errorRecoverySet, isDecl, requiresSignature, isMethod, methodName, indexer, isStatic, markedAsAmbient, modifiers, lambdaArgContext, expectClosingRParen) { var leftCurlyCount = this.scanner.leftCurlyCount; var rightCurlyCount = this.scanner.rightCurlyCount; var prevInConstr = this.parsingClassConstructorDefinition; this.parsingClassConstructorDefinition = false; var name = null; var fnMin = this.scanner.startPos; var minChar = this.scanner.pos; var prevNestingLevel = this.nestingLevel; var preComments = this.parseComments(); var isLambda = !!lambdaArgContext; this.nestingLevel = 0; if((!this.style_funcInLoop) && this.inLoop()) { this.reportParseStyleError("function declaration in loop"); } if(!isMethod && !isStatic && !indexer && !lambdaArgContext) { this.currentToken = this.scanner.scan(); this.state = ParseState.StartFncDecl; if((this.currentToken.tokenId != TypeScript.TokenID.Identifier) && (!TypeScript.convertTokToID(this.currentToken, this.strictMode))) { if(isDecl) { this.reportParseError("Function declaration must include identifier"); this.nestingLevel = prevNestingLevel; return new TypeScript.IncompleteAST(fnMin, this.scanner.pos); } } else { name = TypeScript.Identifier.fromToken(this.currentToken); name.minChar = this.scanner.startPos; name.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); } } else { if(methodName) { name = methodName; } } this.state = ParseState.FncDeclName; var args = new TypeScript.ASTList(); var variableArgList = false; var isOverload = false; var isGetter = TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Getter); var isSetter = TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Setter); if((this.currentToken.tokenId == TypeScript.TokenID.OpenParen) || (indexer && (this.currentToken.tokenId == TypeScript.TokenID.OpenBracket)) || (lambdaArgContext && (lambdaArgContext.preProcessedLambdaArgs || this.currentToken.tokenId == TypeScript.TokenID.DotDotDot))) { variableArgList = this.parseFormalParameterList(errorRecoverySet, args, false, requiresSignature, indexer, isGetter, isSetter, isLambda, lambdaArgContext ? lambdaArgContext.preProcessedLambdaArgs : null, expectClosingRParen); } this.state = ParseState.FncDeclArgs; var returnType = null; if(this.currentToken.tokenId == TypeScript.TokenID.Colon) { this.currentToken = this.scanner.scan(); if(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Setter)) { this.reportParseError("Property setters may not declare a return type"); } returnType = this.parseTypeReference(errorRecoverySet, true); } if(indexer && args.members.length == 0) { this.reportParseError("Index signatures require a parameter type to be specified"); } this.state = ParseState.FncDeclReturnType; if(isLambda && this.currentToken.tokenId != TypeScript.TokenID.EqualsGreaterThan) { this.reportParseError("Expected '=>'"); } if(isDecl && !(this.parsingDeclareFile || markedAsAmbient) && (!isMethod || !(this.ambientModule || this.ambientClass || this.inInterfaceDecl)) && this.currentToken.tokenId == TypeScript.TokenID.Semicolon) { isOverload = true; isDecl = false; requiresSignature = true; } var svInFncDecl = this.inFncDecl; this.inFncDecl = true; var funcDecl = this.parseFunctionStatements(errorRecoverySet | TypeScript.ErrorRecoverySet.RCurly, name, false, isMethod, args, TypeScript.AllowedElements.None, minChar, requiresSignature, TypeScript.Modifiers.None); this.inFncDecl = svInFncDecl; funcDecl.variableArgList = variableArgList; funcDecl.isOverload = isOverload; if(!requiresSignature) { funcDecl.fncFlags |= TypeScript.FncFlags.Definition; } if(isStatic) { funcDecl.fncFlags |= TypeScript.FncFlags.Static; } if(requiresSignature) { funcDecl.fncFlags |= TypeScript.FncFlags.Signature; } if(indexer) { funcDecl.fncFlags |= TypeScript.FncFlags.IndexerMember; } funcDecl.returnTypeAnnotation = returnType; if(isMethod) { funcDecl.fncFlags |= TypeScript.FncFlags.Method; funcDecl.fncFlags |= TypeScript.FncFlags.ClassPropertyMethodExported; } funcDecl.leftCurlyCount = this.scanner.leftCurlyCount - leftCurlyCount; funcDecl.rightCurlyCount = this.scanner.rightCurlyCount - rightCurlyCount; this.nestingLevel = prevNestingLevel; this.parsingClassConstructorDefinition = prevInConstr; funcDecl.preComments = preComments; return funcDecl; }; Parser.prototype.convertToTypeReference = function (ast) { var result; switch(ast.nodeType) { case TypeScript.NodeType.TypeRef: { return ast; } case TypeScript.NodeType.Name: { result = new TypeScript.TypeReference(ast, 0); result.minChar = ast.minChar; result.limChar = ast.limChar; return result; } case TypeScript.NodeType.Index: { var expr = ast; result = this.convertToTypeReference(expr.operand1); if(result) { result.arrayCount++; result.minChar = expr.minChar; result.limChar = expr.limChar; return result; } else { var etr = new TypeScript.AST(TypeScript.NodeType.Error); return etr; } } } return null; }; Parser.prototype.parseArgList = function (errorRecoverySet) { var args = new TypeScript.ASTList(); args.minChar = this.scanner.startPos; this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId !== TypeScript.TokenID.CloseParen) { while(true) { if(args.members.length > 65535) { this.reportParseError("max number of args exceeded"); break; } var arg = this.parseExpr(TypeScript.ErrorRecoverySet.Comma | errorRecoverySet, TypeScript.OperatorPrecedence.Comma, true, TypeContext.NoTypes); args.append(arg); if(this.currentToken.tokenId != TypeScript.TokenID.Comma) { break; } this.currentToken = this.scanner.scan(); } } args.limChar = this.scanner.pos; return args; }; Parser.prototype.parseBaseList = function (extendsList, implementsList, errorRecoverySet, isClass) { var keyword = true; var currentList = extendsList; for(; ; ) { if(keyword) { if(this.currentToken.tokenId === TypeScript.TokenID.Implements) { currentList = implementsList; } else { if(this.currentToken.tokenId == TypeScript.TokenID.Extends && !this.requiresExtendsBlock) { this.requiresExtendsBlock = isClass; } } this.currentToken = this.scanner.scan(); keyword = false; } var baseName = null; if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { var minChar = this.scanner.startPos; baseName = TypeScript.Identifier.fromToken(this.currentToken); baseName.minChar = minChar; baseName.limChar = this.scanner.pos; baseName = this.parseNamedType(errorRecoverySet | TypeScript.ErrorRecoverySet.LCurly, minChar, baseName, false); } else { this.reportParseError("Expected base name"); if(this.errorRecovery) { baseName = new TypeScript.MissingIdentifier(); baseName.minChar = this.scanner.pos; baseName.limChar = this.scanner.pos; baseName.flags |= TypeScript.ASTFlags.Error; } } if(this.currentToken.tokenId == TypeScript.TokenID.OpenParen) { if(isClass) { this.reportParseError("Base classes may only be initialized via a 'super' call within the constructor body"); } else { this.reportParseError("Interfaces may not be extended with a call expression"); } } else { currentList.append(baseName); } if(isClass && currentList == extendsList && extendsList.members.length > 1) { this.reportParseError("A class may only extend one other class"); } if(this.currentToken.tokenId == TypeScript.TokenID.Comma) { this.currentToken = this.scanner.scan(); continue; } else { if((this.currentToken.tokenId == TypeScript.TokenID.Extends) || (this.currentToken.tokenId == TypeScript.TokenID.Implements)) { if(this.currentToken.tokenId == TypeScript.TokenID.Extends && !this.requiresExtendsBlock) { this.requiresExtendsBlock = isClass; } currentList = extendsList; keyword = true; continue; } } break; } }; Parser.prototype.parseClassDecl = function (errorRecoverySet, minChar, modifiers) { var leftCurlyCount = this.scanner.leftCurlyCount; var rightCurlyCount = this.scanner.rightCurlyCount; if((modifiers & TypeScript.Modifiers.Readonly) != TypeScript.Modifiers.None) { this.reportParseError("const modifier is implicit for class"); } if(this.parsingDeclareFile || this.ambientModule) { modifiers |= TypeScript.Modifiers.Ambient; modifiers |= TypeScript.Modifiers.Exported; } var classIsMarkedAsAmbient = this.parsingDeclareFile || (modifiers & TypeScript.Modifiers.Ambient) != TypeScript.Modifiers.None; var svAmbientClass = this.ambientClass; this.ambientClass = classIsMarkedAsAmbient; this.currentToken = this.scanner.scan(); var name = null; if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || (!TypeScript.isPrimitiveTypeToken(this.currentToken) && TypeScript.convertTokToID(this.currentToken, this.strictMode))) { name = TypeScript.Identifier.fromToken(this.currentToken); name.minChar = this.scanner.startPos; name.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); } else { this.reportParseError("class missing name"); if(this.errorRecovery) { name = new TypeScript.MissingIdentifier(); name.minChar = this.scanner.pos; name.limChar = this.scanner.pos; name.flags |= TypeScript.ASTFlags.Error; } } var extendsList = null; var implementsList = null; var requiresSignature = false; if((this.currentToken.tokenId == TypeScript.TokenID.Extends) || (this.currentToken.tokenId == TypeScript.TokenID.Implements)) { extendsList = new TypeScript.ASTList(); implementsList = new TypeScript.ASTList(); this.parseBaseList(extendsList, implementsList, errorRecoverySet, true); } var classDecl = new TypeScript.ClassDeclaration(name, new TypeScript.ASTList(), extendsList, implementsList); this.currentClassDefinition = classDecl; this.parseClassElements(classDecl, errorRecoverySet, modifiers); if(this.ambientModule || this.parsingDeclareFile || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported)) { classDecl.varFlags |= TypeScript.VarFlags.Exported; } if(this.ambientModule || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)) { classDecl.varFlags |= TypeScript.VarFlags.Ambient; } classDecl.varFlags |= TypeScript.VarFlags.Class; this.ambientClass = svAmbientClass; classDecl.leftCurlyCount = this.scanner.leftCurlyCount - leftCurlyCount; classDecl.rightCurlyCount = this.scanner.rightCurlyCount - rightCurlyCount; return classDecl; }; Parser.prototype.parseClassElements = function (classDecl, errorRecoverySet, parentModifiers) { var modifiers = parentModifiers; var resetModifiers = false; var membersMinChar = this.scanner.startPos; this.checkCurrentToken(TypeScript.TokenID.OpenBrace, errorRecoverySet); this.nestingLevel++; var currentMemberMinChar = this.scanner.startPos; var wasGetOrSetId = false; while(!(this.currentToken.tokenId == TypeScript.TokenID.CloseBrace || this.currentToken.tokenId == TypeScript.TokenID.EndOfFile)) { var scanNext = true; var publicOrPrivateFlags = TypeScript.Modifiers.Public | TypeScript.Modifiers.Private; if(this.currentToken.tokenId == TypeScript.TokenID.Get) { if(modifiers & TypeScript.Modifiers.Getter) { this.reportParseError("Duplicate 'get' declaration in class body"); } if(modifiers & TypeScript.Modifiers.Setter) { this.reportParseError("Getter already marked as a setter"); } modifiers |= TypeScript.Modifiers.Getter; } else { if(this.currentToken.tokenId == TypeScript.TokenID.Set) { if(modifiers & TypeScript.Modifiers.Setter) { this.reportParseError("Duplicate 'set' declaration in class body"); } if(modifiers & TypeScript.Modifiers.Getter) { this.reportParseError("Setter already marked as a getter"); } modifiers |= TypeScript.Modifiers.Setter; } else { if(this.currentToken.tokenId == TypeScript.TokenID.Private) { if(modifiers & publicOrPrivateFlags) { this.reportParseError("Multiple modifiers may not be applied to class members"); } modifiers |= TypeScript.Modifiers.Private; } else { if(this.currentToken.tokenId == TypeScript.TokenID.Public) { if(modifiers & publicOrPrivateFlags) { this.reportParseError("Multiple modifiers may not be applied to class members"); } modifiers |= TypeScript.Modifiers.Public; } else { if(this.currentToken.tokenId == TypeScript.TokenID.Static) { if(modifiers & TypeScript.Modifiers.Static) { this.reportParseError("Multiple modifiers may not be applied to class members"); } modifiers |= TypeScript.Modifiers.Static; } else { if(this.currentToken.tokenId == TypeScript.TokenID.Constructor) { if(modifiers != parentModifiers) { this.reportParseError("Constructors may not have modifiers"); } this.parseClassConstructorDeclaration(currentMemberMinChar, errorRecoverySet, modifiers); scanNext = false; resetModifiers = true; } else { if(wasGetOrSetId || this.currentToken.tokenId == TypeScript.TokenID.Identifier || TypeScript.convertTokToIDName(this.currentToken)) { var idText = wasGetOrSetId ? ((modifiers & TypeScript.Modifiers.Getter) ? "get" : "set") : this.currentToken.getText(); var id = wasGetOrSetId ? new TypeScript.Identifier(idText) : TypeScript.Identifier.fromToken(this.currentToken); id.minChar = this.scanner.startPos; id.limChar = this.scanner.pos; if(wasGetOrSetId) { modifiers = modifiers ^ ((modifiers & TypeScript.Modifiers.Getter) ? TypeScript.Modifiers.Getter : TypeScript.Modifiers.Setter); wasGetOrSetId = false; } else { this.currentToken = this.scanner.scan(); } if(this.currentToken.tokenId == TypeScript.TokenID.OpenParen) { this.parseClassMemberFunctionDeclaration(id, currentMemberMinChar, errorRecoverySet, modifiers); scanNext = false; } else { if(modifiers & TypeScript.Modifiers.Getter || modifiers & TypeScript.Modifiers.Setter) { this.reportParseError("Property accessors must be functions"); } var varDecl = this.parseClassMemberVariableDeclaration(id, currentMemberMinChar, false, errorRecoverySet, modifiers); if(varDecl.init && varDecl.init.nodeType == TypeScript.NodeType.FuncDecl) { if(this.currentToken.tokenId == TypeScript.TokenID.CloseBrace) { scanNext = false; } } else { if(varDecl.init && varDecl.init.nodeType == TypeScript.NodeType.ObjectLit && this.currentToken.tokenId != TypeScript.TokenID.Semicolon) { scanNext = false; varDecl.init.flags |= TypeScript.ASTFlags.AutomaticSemicolon; } else { if(this.currentToken.tokenId != TypeScript.TokenID.Semicolon) { this.reportParseError("Expected ';'"); scanNext = false; } } } } resetModifiers = true; } else { if(this.currentToken.tokenId == TypeScript.TokenID.Super) { this.reportParseError("Base class initializers must be the first statement in a class definition"); } else { if(!wasGetOrSetId && ((modifiers & TypeScript.Modifiers.Getter) || (modifiers & TypeScript.Modifiers.Setter)) && ((this.currentToken.tokenId == TypeScript.TokenID.OpenParen) || (this.currentToken.tokenId == TypeScript.TokenID.Equals) || (this.currentToken.tokenId == TypeScript.TokenID.Colon) || (this.currentToken.tokenId == TypeScript.TokenID.Semicolon))) { wasGetOrSetId = true; scanNext = false; } else { if(this.currentToken.tokenId != TypeScript.TokenID.Semicolon) { this.reportParseError("Unexpected '" + this.currentToken.getText() + "' in class definition"); resetModifiers = true; } } } } } } } } } } if(scanNext) { this.currentToken = this.scanner.scan(); if (this.currentToken === undefined) this.currentToken = this.scanner.scan(); } if(resetModifiers) { modifiers = parentModifiers; currentMemberMinChar = this.scanner.startPos; resetModifiers = false; } } var membersLimChar = this.scanner.pos; if(this.currentToken.tokenId == TypeScript.TokenID.CloseBrace) { classDecl.endingToken = new TypeScript.ASTSpan(); classDecl.endingToken.minChar = this.scanner.startPos; classDecl.endingToken.limChar = this.scanner.pos; if(!this.currentClassDefinition.members.members.length) { this.currentClassDefinition.preComments = this.parseComments(); } this.currentToken = this.scanner.scan(); } this.nestingLevel--; this.currentClassDefinition.members.minChar = membersMinChar; this.currentClassDefinition.members.limChar = membersLimChar; this.currentClassDefinition.limChar = membersLimChar; this.currentClassDefinition = null; }; Parser.prototype.parseClassConstructorDeclaration = function (minChar, errorRecoverySet, modifiers) { this.parsingClassConstructorDefinition = true; var isAmbient = this.parsingDeclareFile || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient); var args = new TypeScript.ASTList(); var variableArgList = false; var preComments = this.parseComments(); this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.OpenParen) { variableArgList = this.parseFormalParameterList(errorRecoverySet, args, true, isAmbient, false, false, false, false, null, true); if(args.members.length > 0) { var lastArg = args.members[args.members.length - 1]; } } var requiresSignature = isAmbient || this.currentToken.tokenId == TypeScript.TokenID.Semicolon; if(requiresSignature) { for(var i = 0; i < args.members.length; i++) { var arg = args.members[i]; if(TypeScript.hasFlag(arg.varFlags, TypeScript.VarFlags.Property)) { this.reportParseError("Overload or ambient signatures may not specify parameter properties", arg.minChar, arg.limChar); } } } if(!requiresSignature) { this.currentClassDefinition.constructorNestingLevel = this.nestingLevel + 1; } var constructorFuncDecl = this.parseFunctionStatements(errorRecoverySet | TypeScript.ErrorRecoverySet.RCurly, this.currentClassDefinition.name, true, false, args, TypeScript.AllowedElements.Properties, minChar, requiresSignature, modifiers); constructorFuncDecl.preComments = preComments; if(requiresSignature && !isAmbient) { constructorFuncDecl.isOverload = true; } constructorFuncDecl.variableArgList = variableArgList; this.currentClassDecl = null; constructorFuncDecl.returnTypeAnnotation = this.convertToTypeReference(this.currentClassDefinition.name); constructorFuncDecl.classDecl = this.currentClassDefinition; if(isAmbient) { constructorFuncDecl.fncFlags |= TypeScript.FncFlags.Ambient; } if(requiresSignature) { constructorFuncDecl.fncFlags |= TypeScript.FncFlags.Signature; } if(this.ambientModule || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported)) { constructorFuncDecl.fncFlags |= TypeScript.FncFlags.Exported; } if(this.currentClassDefinition.constructorDecl) { if(!isAmbient && !this.currentClassDefinition.constructorDecl.isSignature() && !constructorFuncDecl.isSignature()) { this.reportParseError("Duplicate constructor definition"); } } if(isAmbient || !constructorFuncDecl.isSignature()) { this.currentClassDefinition.constructorDecl = constructorFuncDecl; } constructorFuncDecl.fncFlags |= TypeScript.FncFlags.ClassMethod; this.currentClassDefinition.members.members[this.currentClassDefinition.members.members.length] = constructorFuncDecl; this.parsingClassConstructorDefinition = false; return constructorFuncDecl; }; Parser.prototype.parseClassMemberVariableDeclaration = function (text, minChar, isDeclaredInConstructor, errorRecoverySet, modifiers) { var varDecl = new TypeScript.VarDecl(text, this.nestingLevel); varDecl.minChar = minChar; var isStatic = false; varDecl.preComments = this.parseComments(); if(this.currentToken.tokenId == TypeScript.TokenID.Colon) { this.currentToken = this.scanner.scan(); varDecl.typeExpr = this.parseTypeReference(errorRecoverySet | TypeScript.ErrorRecoverySet.Asg | TypeScript.ErrorRecoverySet.Comma, false); if(varDecl.typeExpr && varDecl.typeExpr.nodeType == TypeScript.NodeType.TypeRef) { var typeExpr = (varDecl.typeExpr); if(typeExpr.term && typeExpr.term.nodeType == TypeScript.NodeType.FuncDecl) { typeExpr.term.preComments = varDecl.preComments; } } } if(this.currentToken.tokenId == TypeScript.TokenID.Equals) { if(this.parsingDeclareFile || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)) { this.reportParseError("context does not permit variable initializer"); if(this.errorRecovery) { this.skip(errorRecoverySet); varDecl.flags |= TypeScript.ASTFlags.Error; varDecl.limChar = this.scanner.lastTokenLimChar(); return varDecl; } } this.currentToken = this.scanner.scan(); varDecl.init = this.parseExpr(TypeScript.ErrorRecoverySet.Comma | errorRecoverySet, TypeScript.OperatorPrecedence.Comma, true, TypeContext.NoTypes); varDecl.limChar = varDecl.init.limChar; if(!(modifiers & TypeScript.Modifiers.Static)) { this.currentClassDefinition.varFlags |= TypeScript.VarFlags.ClassSuperMustBeFirstCallInConstructor; } } else { varDecl.limChar = this.scanner.pos; } if(modifiers & TypeScript.Modifiers.Static) { varDecl.varFlags |= TypeScript.VarFlags.Static; isStatic = true; } if((modifiers & TypeScript.Modifiers.Private) != TypeScript.Modifiers.None) { varDecl.varFlags |= TypeScript.VarFlags.Private; } else { varDecl.varFlags |= TypeScript.VarFlags.Public; } varDecl.varFlags |= TypeScript.VarFlags.Property; if(isDeclaredInConstructor) { varDecl.varFlags |= TypeScript.VarFlags.ClassConstructorProperty; } if(!isDeclaredInConstructor && !isStatic) { varDecl.varFlags |= TypeScript.VarFlags.ClassBodyProperty; } this.currentClassDefinition.knownMemberNames[text.actualText] = true; if(!isDeclaredInConstructor) { this.currentClassDefinition.members.members[this.currentClassDefinition.members.members.length] = varDecl; } varDecl.postComments = this.parseComments(); return varDecl; }; Parser.prototype.parseClassMemberFunctionDeclaration = function (methodName, minChar, errorRecoverySet, modifiers) { var wasAccessorID = this.prevIDTok != null; var isAccessor = TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Getter) || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Setter); var isStatic = TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Static); var isAmbient = this.ambientModule || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient); errorRecoverySet |= TypeScript.ErrorRecoverySet.RParen; if(isAccessor && (modifiers & TypeScript.Modifiers.Ambient)) { this.reportParseError("Property accessors may not be declared in ambient classes"); } var ast = this.parseFncDecl(errorRecoverySet, true, isAmbient, true, methodName, false, isStatic, isAmbient, modifiers, null, true); if(ast.nodeType == TypeScript.NodeType.Error) { return ast; } var funcDecl = ast; funcDecl.minChar = minChar; if(funcDecl.bod !== null) { funcDecl.limChar = funcDecl.bod.limChar; } if(modifiers & TypeScript.Modifiers.Private) { funcDecl.fncFlags |= TypeScript.FncFlags.Private; } else { funcDecl.fncFlags |= TypeScript.FncFlags.Public; } if(isStatic) { funcDecl.fncFlags |= TypeScript.FncFlags.Static; } if(isAccessor) { if(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Getter)) { funcDecl.fncFlags |= TypeScript.FncFlags.GetAccessor; funcDecl.hint = "get" + funcDecl.name.actualText; } else { funcDecl.fncFlags |= TypeScript.FncFlags.SetAccessor; funcDecl.hint = "set" + funcDecl.name.actualText; } funcDecl.fncFlags |= TypeScript.FncFlags.IsFunctionExpression; if(TypeScript.codeGenTarget < TypeScript.CodeGenTarget.ES5) { this.reportParseError("Property accessors are only available when targeting ES5 or greater", funcDecl.minChar, funcDecl.limChar); } } funcDecl.fncFlags |= TypeScript.FncFlags.ClassMethod; this.currentClassDefinition.knownMemberNames[methodName.actualText] = true; this.currentClassDefinition.members.members[this.currentClassDefinition.members.members.length] = funcDecl; return funcDecl; }; Parser.prototype.parseTypeMember = function (errorRecoverySet) { var minChar = this.scanner.startPos; var propertyDecl = this.parsePropertyDeclaration(errorRecoverySet, TypeScript.Modifiers.Public, true, false); if(propertyDecl) { propertyDecl.minChar = minChar; if(propertyDecl.nodeType == TypeScript.NodeType.VarDecl) { this.checkCurrentToken(TypeScript.TokenID.Semicolon, errorRecoverySet); } } return propertyDecl; }; Parser.prototype.parseTypeMemberList = function (errorRecoverySet, members) { errorRecoverySet |= TypeScript.ErrorRecoverySet.TypeScriptS; while(true) { switch(this.currentToken.tokenId) { case TypeScript.TokenID.CloseBrace: case TypeScript.TokenID.EndOfFile: { members.limChar = this.scanner.pos; return; } } var element = this.parseTypeMember(errorRecoverySet); if(element) { members.append(element); } } }; Parser.prototype.parseInterfaceDecl = function (errorRecoverySet, modifiers) { var leftCurlyCount = this.scanner.leftCurlyCount; var rightCurlyCount = this.scanner.rightCurlyCount; this.currentToken = this.scanner.scan(); var minChar = this.scanner.pos; var name = null; if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || (!TypeScript.isPrimitiveTypeToken(this.currentToken) && TypeScript.convertTokToID(this.currentToken, this.strictMode))) { name = TypeScript.Identifier.fromToken(this.currentToken); name.minChar = this.scanner.startPos; name.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); } else { this.reportParseError("interface missing name"); if(this.errorRecovery) { name = new TypeScript.MissingIdentifier(); name.minChar = this.scanner.pos; name.limChar = this.scanner.pos; name.flags |= TypeScript.ASTFlags.Error; } } var extendsList = null; var implementsList = null; if(this.currentToken.tokenId === TypeScript.TokenID.Extends || this.currentToken.tokenId === TypeScript.TokenID.Implements) { if(this.currentToken.tokenId === TypeScript.TokenID.Implements) { this.reportParseError("Expected 'extends'"); } extendsList = new TypeScript.ASTList(); implementsList = new TypeScript.ASTList(); extendsList.minChar = this.scanner.startPos; this.parseBaseList(extendsList, implementsList, errorRecoverySet, false); } var membersMinChar = this.scanner.startPos; this.checkCurrentToken(TypeScript.TokenID.OpenBrace, errorRecoverySet | TypeScript.ErrorRecoverySet.TypeScriptS); var members = new TypeScript.ASTList(); members.minChar = membersMinChar; var prevInInterfaceDecl = this.inInterfaceDecl; this.inInterfaceDecl = true; this.parseTypeMemberList(errorRecoverySet | TypeScript.ErrorRecoverySet.RCurly, members); this.inInterfaceDecl = prevInInterfaceDecl; this.checkCurrentToken(TypeScript.TokenID.CloseBrace, errorRecoverySet); var interfaceDecl = new TypeScript.InterfaceDeclaration(name, members, extendsList, null); if(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Private)) { interfaceDecl.varFlags |= TypeScript.VarFlags.Private; } if(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Public)) { interfaceDecl.varFlags |= TypeScript.VarFlags.Public; } if(this.parsingDeclareFile || this.ambientModule || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported)) { interfaceDecl.varFlags |= TypeScript.VarFlags.Exported; } interfaceDecl.limChar = members.limChar; interfaceDecl.leftCurlyCount = this.scanner.leftCurlyCount - leftCurlyCount; interfaceDecl.rightCurlyCount = this.scanner.rightCurlyCount - rightCurlyCount; return interfaceDecl; }; Parser.prototype.makeVarDecl = function (id, nest) { var varDecl = new TypeScript.VarDecl(id, nest); var currentVarList = this.topVarList(); if(currentVarList) { currentVarList.append(varDecl); } return varDecl; }; Parser.prototype.parsePropertyDeclaration = function (errorRecoverySet, modifiers, requireSignature, isStatic) { var text = null; var minChar = this.scanner.startPos; var nameLimChar = minChar; var isNew = false; var isIndexer = false; var wasAccessorID = this.prevIDTok != null; var isAccessor = TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Getter) || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Setter); if(this.parsingDeclareFile || this.ambientModule || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)) { requireSignature = true; } if(this.currentToken.tokenId == TypeScript.TokenID.OpenParen && !wasAccessorID) { if(!requireSignature && !isStatic) { this.reportParseError("Expected identifier in property declaration"); if(this.errorRecovery) { this.skip(errorRecoverySet); text = new TypeScript.MissingIdentifier(); } } } else { if(this.currentToken.tokenId == TypeScript.TokenID.New) { if(requireSignature) { this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.OpenParen) { isNew = true; } } if(!isNew) { if(!requireSignature) { this.currentToken = this.scanner.scan(); } text = new TypeScript.Identifier("new"); text.minChar = this.scanner.pos - 3; text.limChar = this.scanner.pos; nameLimChar = this.scanner.pos; } } else { if((this.currentToken.tokenId == TypeScript.TokenID.OpenBracket) && requireSignature) { isIndexer = true; text = new TypeScript.Identifier("__item"); } else { if((this.currentToken.tokenId != TypeScript.TokenID.Identifier) && (!TypeScript.convertTokToIDName(this.currentToken)) && !wasAccessorID) { this.reportParseError("Expected identifier in property declaration"); if(this.errorRecovery) { var eminChar = this.scanner.startPos; var curpos = this.scanner.pos; this.skip(errorRecoverySet & (~TypeScript.ErrorRecoverySet.Comma)); if(this.scanner.pos == curpos) { this.currentToken = this.scanner.scan(); } var epd = new TypeScript.VarDecl(new TypeScript.MissingIdentifier(), this.nestingLevel); epd.flags |= TypeScript.ASTFlags.Error; epd.minChar = eminChar; epd.limChar = this.scanner.lastTokenLimChar(); return epd; } } else { if(wasAccessorID) { text = TypeScript.Identifier.fromToken(this.prevIDTok); text.minChar = this.scanner.lastTokenLimChar() - 3; text.limChar = this.scanner.lastTokenLimChar(); nameLimChar = text.limChar; if(TypeScript.codeGenTarget < TypeScript.CodeGenTarget.ES5) { this.reportParseError("Property accessors are only available when targeting ES5 or greater"); } if(this.currentToken.getText() == text.actualText && this.currentToken != this.prevIDTok) { this.currentToken = this.scanner.scan(); } this.prevIDTok = null; } else { text = TypeScript.Identifier.fromToken(this.currentToken); text.minChar = this.scanner.startPos; text.limChar = this.scanner.pos; nameLimChar = this.scanner.pos; this.currentToken = this.scanner.scan(); } } } } } if(this.currentToken.tokenId == TypeScript.TokenID.Question) { if(this.inInterfaceDecl && text) { text.flags |= TypeScript.ASTFlags.OptionalName; } else { this.reportParseError("Optional properties may only be declared on interface or object types"); } this.currentToken = this.scanner.scan(); } if((this.currentToken.tokenId == TypeScript.TokenID.OpenParen) || (isIndexer && (this.currentToken.tokenId == TypeScript.TokenID.OpenBracket))) { var ers = errorRecoverySet | TypeScript.ErrorRecoverySet.RParen; if(isIndexer) { ers = errorRecoverySet | TypeScript.ErrorRecoverySet.RBrack; } var ast = this.parseFncDecl(ers, true, requireSignature, !this.inFncDecl, text, isIndexer, isStatic, (this.parsingDeclareFile || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)), modifiers, null, true); var funcDecl; if(ast.nodeType == TypeScript.NodeType.Error) { return ast; } else { funcDecl = ast; } if(funcDecl.name) { funcDecl.name.minChar = minChar; funcDecl.name.limChar = nameLimChar; } if((modifiers & TypeScript.Modifiers.Public) != TypeScript.Modifiers.None) { funcDecl.fncFlags |= TypeScript.FncFlags.Public; } if((modifiers & TypeScript.Modifiers.Private) != TypeScript.Modifiers.None) { funcDecl.fncFlags |= TypeScript.FncFlags.Private; } if(isStatic) { funcDecl.fncFlags |= TypeScript.FncFlags.Static; } if(this.parsingDeclareFile || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)) { funcDecl.fncFlags |= TypeScript.FncFlags.Ambient; } if(isAccessor) { if(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Getter)) { funcDecl.fncFlags |= TypeScript.FncFlags.GetAccessor; funcDecl.hint = "get" + funcDecl.name.actualText; } else { funcDecl.fncFlags |= TypeScript.FncFlags.SetAccessor; funcDecl.hint = "set" + funcDecl.name.actualText; } funcDecl.fncFlags |= TypeScript.FncFlags.IsFunctionExpression; if(modifiers & TypeScript.Modifiers.Ambient) { this.reportParseError("Property accessors may not be declared in ambient types"); } } if(text == null) { if(isNew) { funcDecl.fncFlags |= TypeScript.FncFlags.ConstructMember; funcDecl.hint = "_construct"; funcDecl.classDecl = this.currentClassDecl; } else { funcDecl.hint = "_call"; funcDecl.fncFlags |= TypeScript.FncFlags.CallMember; } } return funcDecl; } else { var varDecl = new TypeScript.VarDecl(text, this.nestingLevel); varDecl.preComments = this.parseComments(); varDecl.minChar = minChar; if(this.currentToken.tokenId == TypeScript.TokenID.Colon) { this.currentToken = this.scanner.scan(); varDecl.typeExpr = this.parseTypeReference(errorRecoverySet | TypeScript.ErrorRecoverySet.Asg | TypeScript.ErrorRecoverySet.Comma, false); if(varDecl.typeExpr && varDecl.typeExpr.nodeType == TypeScript.NodeType.TypeRef) { var typeExpr = (varDecl.typeExpr); if(typeExpr.term && typeExpr.term.nodeType == TypeScript.NodeType.FuncDecl) { typeExpr.term.preComments = varDecl.preComments; } } } if(this.currentToken.tokenId == TypeScript.TokenID.Equals) { if(requireSignature) { this.reportParseError("context does not permit variable initializer"); if(this.errorRecovery) { this.skip(errorRecoverySet); varDecl.flags |= TypeScript.ASTFlags.Error; varDecl.limChar = this.scanner.lastTokenLimChar(); return varDecl; } } this.currentToken = this.scanner.scan(); varDecl.init = this.parseExpr(TypeScript.ErrorRecoverySet.Comma | errorRecoverySet, TypeScript.OperatorPrecedence.Comma, true, TypeContext.NoTypes); varDecl.limChar = varDecl.init.limChar; if(varDecl.init.nodeType == TypeScript.NodeType.FuncDecl) { var funcDecl = varDecl.init; funcDecl.hint = varDecl.id.text; funcDecl.boundToProperty = varDecl; } else { if(isAccessor) { this.reportParseError("Accessors may only be functions"); } } } else { varDecl.limChar = this.scanner.pos; } if((modifiers & TypeScript.Modifiers.Readonly) != TypeScript.Modifiers.None) { varDecl.varFlags |= TypeScript.VarFlags.Readonly; } if(isStatic) { varDecl.varFlags |= TypeScript.VarFlags.Static; } if((modifiers & TypeScript.Modifiers.Public) != TypeScript.Modifiers.None) { varDecl.varFlags |= TypeScript.VarFlags.Public; } if((modifiers & TypeScript.Modifiers.Private) != TypeScript.Modifiers.None) { varDecl.varFlags |= TypeScript.VarFlags.Private; } varDecl.varFlags |= TypeScript.VarFlags.Property; return varDecl; } }; Parser.prototype.parseVariableDeclaration = function (errorRecoverySet, modifiers, allowIn, isStatic) { var isConst = TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Readonly); var minChar = this.scanner.startPos; var varDecl = null; var declList = null; var multivar = false; this.currentToken = this.scanner.scan(); var varDeclPreComments = this.parseComments(); while(true) { if((this.currentToken.tokenId != TypeScript.TokenID.Identifier) && (!TypeScript.convertTokToID(this.currentToken, this.strictMode))) { this.reportParseError("Expected identifier in variable declaration"); if(this.errorRecovery) { varDecl = new TypeScript.VarDecl(new TypeScript.MissingIdentifier(), this.nestingLevel); varDecl.minChar = minChar; this.skip(errorRecoverySet); varDecl.flags |= TypeScript.ASTFlags.Error; varDecl.limChar = this.scanner.lastTokenLimChar(); return varDecl; } } var varDeclName = TypeScript.Identifier.fromToken(this.currentToken); if(this.strictMode && (varDeclName.text == "eval")) { this.reportParseError("'eval' may not name a variable in strict mode"); } varDecl = this.makeVarDecl(varDeclName, this.nestingLevel); varDecl.id.minChar = this.scanner.startPos; varDecl.id.limChar = this.scanner.pos; varDecl.preComments = varDeclPreComments; if(isStatic) { varDecl.varFlags |= TypeScript.VarFlags.Static; } if(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Readonly)) { varDecl.varFlags |= TypeScript.VarFlags.Readonly; } if(this.parsingDeclareFile || this.ambientModule || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)) { varDecl.varFlags |= TypeScript.VarFlags.Ambient; } if(this.parsingDeclareFile || this.ambientModule || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported)) { varDecl.varFlags |= TypeScript.VarFlags.Exported; } varDecl.minChar = minChar; if(declList) { declList.append(varDecl); } this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.Colon) { this.currentToken = this.scanner.scan(); var prevInFncDecl = this.inFncDecl; this.inFncDecl = false; varDecl.typeExpr = this.parseTypeReference(errorRecoverySet | TypeScript.ErrorRecoverySet.Asg | TypeScript.ErrorRecoverySet.Comma, false); this.inFncDecl = prevInFncDecl; } if(this.currentToken.tokenId == TypeScript.TokenID.Equals) { if(TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Ambient)) { this.reportParseError("Ambient variable can not have an initializer"); } this.currentToken = this.scanner.scan(); varDecl.init = this.parseExpr(TypeScript.ErrorRecoverySet.Comma | errorRecoverySet, TypeScript.OperatorPrecedence.Comma, allowIn, TypeContext.NoTypes); varDecl.limChar = varDecl.init.limChar; if(varDecl.init.nodeType == TypeScript.NodeType.FuncDecl) { var funcDecl = varDecl.init; funcDecl.hint = varDecl.id.actualText; } } else { if(isConst) { this.reportParseError("const declaration requires initializer"); } varDecl.limChar = this.scanner.pos; } varDecl.postComments = this.parseCommentsForLine(this.scanner.line); if(this.currentToken.tokenId != TypeScript.TokenID.Comma) { if(declList) { declList.limChar = varDecl.limChar; return declList; } else { return varDecl; } } if(!multivar) { declList = new TypeScript.ASTList(); declList.minChar = varDecl.minChar; declList.append(varDecl); multivar = true; } this.currentToken = this.scanner.scan(); minChar = this.scanner.startPos; } }; Parser.prototype.parseMemberList = function (errorRecoverySet) { var elements = new TypeScript.ASTList(); if(this.currentToken.tokenId == TypeScript.TokenID.CloseBrace) { return elements; } var idHint = null; var memberName = null; var memberExpr = null; var member = null; var minChar = this.scanner.startPos; var isSet = false; var skippedTokenForGetSetId = false; var getSetTok = null; var getSetStartPos = 0; var getSetPos = 0; for(; ; ) { var accessorPattern = false; if(this.currentToken.tokenId == TypeScript.TokenID.Get || this.currentToken.tokenId == TypeScript.TokenID.Set) { isSet = this.currentToken.tokenId == TypeScript.TokenID.Set; getSetTok = this.currentToken; getSetStartPos = this.scanner.startPos; getSetPos = this.scanner.pos; this.currentToken = this.scanner.scan(); if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToIDName(this.currentToken)) { idHint = isSet ? "set" : "get"; idHint = idHint + this.currentToken.getText(); memberName = TypeScript.Identifier.fromToken(this.currentToken); memberName.minChar = this.scanner.startPos; accessorPattern = true; if(TypeScript.codeGenTarget < TypeScript.CodeGenTarget.ES5) { this.reportParseError("Property accessors are only available when targeting ES5 or greater"); } } else { if(this.currentToken.tokenId != TypeScript.TokenID.Colon) { this.reportParseError("Expected identifier, string or number as accessor name"); } else { skippedTokenForGetSetId = true; memberName = TypeScript.Identifier.fromToken(getSetTok); memberName.minChar = getSetStartPos; memberName.limChar = getSetPos; } } } else { if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToIDName(this.currentToken)) { idHint = this.currentToken.getText(); memberName = TypeScript.Identifier.fromToken(this.currentToken); memberName.minChar = this.scanner.startPos; memberName.limChar = this.scanner.pos; } else { if(this.currentToken.tokenId == TypeScript.TokenID.StringLiteral) { idHint = this.currentToken.getText(); memberName = new TypeScript.StringLiteral(idHint); memberName.minChar = this.scanner.startPos; memberName.limChar = this.scanner.pos; } else { if(this.currentToken.tokenId == TypeScript.TokenID.NumberLiteral) { var ntok = this.currentToken; idHint = ntok.value.toString(); memberName = new TypeScript.StringLiteral(idHint); memberName.minChar = this.scanner.startPos; memberName.limChar = this.scanner.pos; } else { this.reportParseError("Expected identifier, string or number as member name"); if(this.errorRecovery) { memberName = new TypeScript.MissingIdentifier(); memberName.minChar = this.scanner.startPos; memberName.flags |= TypeScript.ASTFlags.Error; this.skip(errorRecoverySet | TypeScript.ErrorRecoverySet.Comma); memberName.limChar = this.scanner.lastTokenLimChar(); } } } } } if(!skippedTokenForGetSetId) { this.currentToken = this.scanner.scan(); } else { skippedTokenForGetSetId = false; } if(this.currentToken.tokenId == TypeScript.TokenID.Question) { memberName.flags |= TypeScript.ASTFlags.OptionalName; this.currentToken = this.scanner.scan(); } if(accessorPattern) { var args = new TypeScript.ASTList(); this.parseFormalParameterList(errorRecoverySet | TypeScript.ErrorRecoverySet.RParen, args, false, true, false, !isSet, isSet, false, null, true); var funcDecl = this.parseFunctionStatements(errorRecoverySet | TypeScript.ErrorRecoverySet.RCurly, memberName, false, true, args, TypeScript.AllowedElements.None, this.scanner.startPos, false, TypeScript.Modifiers.None); if(isSet && funcDecl.returnTypeAnnotation) { this.reportParseError("Property setters may not declare a return type"); } funcDecl.fncFlags |= isSet ? TypeScript.FncFlags.SetAccessor : TypeScript.FncFlags.GetAccessor; funcDecl.fncFlags |= TypeScript.FncFlags.IsFunctionExpression; funcDecl.hint = idHint; memberExpr = funcDecl; member = new TypeScript.BinaryExpression(TypeScript.NodeType.Member, memberName, memberExpr); member.minChar = memberName.minChar; if(memberExpr.nodeType == TypeScript.NodeType.FuncDecl) { var funcDecl = memberExpr; funcDecl.hint = idHint; } } else { if(this.currentToken.tokenId == TypeScript.TokenID.Colon) { this.currentToken = this.scanner.scan(); memberExpr = this.parseExpr(TypeScript.ErrorRecoverySet.Comma | errorRecoverySet, TypeScript.OperatorPrecedence.Comma, true, TypeContext.NoTypes); if(memberExpr.nodeType == TypeScript.NodeType.TypeRef) { this.reportParseError("Expected 'new' on array declaration in member definition"); } member = new TypeScript.BinaryExpression(TypeScript.NodeType.Member, memberName, memberExpr); member.minChar = memberName.minChar; if(memberExpr.nodeType == TypeScript.NodeType.FuncDecl) { var funcDecl = memberExpr; funcDecl.hint = idHint; } } else { this.reportParseError("Expected ':' in member definition"); if(this.errorRecovery) { this.skip(errorRecoverySet); elements.flags |= TypeScript.ASTFlags.Error; elements.minChar = minChar; elements.limChar = this.scanner.lastTokenLimChar(); return elements; } } } idHint = null; elements.append(member); member.limChar = this.scanner.lastTokenLimChar(); if(this.currentToken.tokenId != TypeScript.TokenID.Comma) { break; } else { this.currentToken = this.scanner.scan(); } if(this.currentToken.tokenId == TypeScript.TokenID.CloseBrace) { break; } } if(member) { elements.limChar = member.limChar; } elements.minChar = minChar; return elements; }; Parser.prototype.parseArrayList = function (errorRecoverySet) { var elements = null; if(this.currentToken.tokenId == TypeScript.TokenID.CloseBracket) { return elements; } else { elements = new TypeScript.ASTList(); elements.minChar = this.scanner.startPos; } var arg; for(; ; ) { if((this.currentToken.tokenId == TypeScript.TokenID.Comma) || (this.currentToken.tokenId == TypeScript.TokenID.CloseBracket)) { arg = new TypeScript.AST(TypeScript.NodeType.EmptyExpr); } else { arg = this.parseExpr(TypeScript.ErrorRecoverySet.Comma | errorRecoverySet, TypeScript.OperatorPrecedence.Comma, true, TypeContext.NoTypes); } elements.append(arg); if(this.currentToken.tokenId != TypeScript.TokenID.Comma) { break; } this.currentToken = this.scanner.scan(); } elements.limChar = this.scanner.lastTokenLimChar(); return elements; }; Parser.prototype.parseArrayLiteral = function (errorRecoverySet) { var arrayLiteral = null; arrayLiteral = new TypeScript.UnaryExpression(TypeScript.NodeType.ArrayLit, this.parseArrayList(errorRecoverySet)); return arrayLiteral; }; Parser.prototype.parseTerm = function (errorRecoverySet, allowCall, typeContext, inCast) { var ast = null; var sawId = false; var inNew = false; var minChar = this.scanner.startPos; var limChar = this.scanner.pos; var parseAsLambda = false; var expectlambdaRParen = false; switch(this.currentToken.tokenId) { case TypeScript.TokenID.Number: case TypeScript.TokenID.Bool: case TypeScript.TokenID.Any: case TypeScript.TokenID.String: { var tid = new TypeScript.Identifier(TypeScript.tokenTable[this.currentToken.tokenId].text); if(TypeScript.hasFlag(typeContext, TypeContext.Primitive)) { ast = new TypeScript.TypeReference(tid, 0); sawId = true; } else { ast = tid; sawId = true; } ast.minChar = minChar; this.currentToken = this.scanner.scan(); limChar = this.scanner.lastTokenLimChar(); break; } case TypeScript.TokenID.This: { ast = new TypeScript.AST(TypeScript.NodeType.This); ast.minChar = minChar; this.currentToken = this.scanner.scan(); limChar = this.scanner.lastTokenLimChar(); break; } case TypeScript.TokenID.Super: { ast = new TypeScript.AST(TypeScript.NodeType.Super); ast.minChar = minChar; this.currentToken = this.scanner.scan(); limChar = this.scanner.lastTokenLimChar(); break; } case TypeScript.TokenID.True: { ast = new TypeScript.AST(TypeScript.NodeType.True); this.currentToken = this.scanner.scan(); ast.minChar = minChar; break; } case TypeScript.TokenID.False: { ast = new TypeScript.AST(TypeScript.NodeType.False); this.currentToken = this.scanner.scan(); ast.minChar = minChar; break; } case TypeScript.TokenID.Null: { ast = new TypeScript.AST(TypeScript.NodeType.Null); this.currentToken = this.scanner.scan(); ast.minChar = minChar; break; } case TypeScript.TokenID.New: { minChar = this.scanner.pos; this.currentToken = this.scanner.scan(); var target = this.parseTerm(errorRecoverySet, false, TypeContext.AllSimpleTypes, inCast); if(target.nodeType == TypeScript.NodeType.Error || (target.nodeType == TypeScript.NodeType.Index && (target).operand1.nodeType == TypeScript.NodeType.TypeRef)) { this.reportParseError("Cannot invoke 'new' on this expression"); } else { ast = new TypeScript.CallExpression(TypeScript.NodeType.New, target, null); ast.minChar = minChar; limChar = this.scanner.lastTokenLimChar(); inNew = true; } break; } case TypeScript.TokenID.Function: { minChar = this.scanner.pos; ast = this.parseFncDecl(errorRecoverySet, false, false, false, null, false, false, false, TypeScript.Modifiers.None, null, true); (ast).fncFlags |= TypeScript.FncFlags.IsFunctionExpression; ast.minChar = minChar; limChar = this.scanner.lastTokenLimChar(); ast.limChar = limChar; break; } } if(ast == null) { if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { var idText = this.currentToken.getText(); ast = this.createRef(idText, (this.currentToken).hasEscapeSequence, minChar); sawId = true; ast.minChar = minChar; this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.Question) { ast.flags |= TypeScript.ASTFlags.PossibleOptionalParameter; } limChar = this.scanner.lastTokenLimChar(); } } if(inCast) { this.checkCurrentToken(TypeScript.TokenID.GreaterThan, errorRecoverySet); } if(ast == null) { switch(this.currentToken.tokenId) { case TypeScript.TokenID.OpenParen: { minChar = this.scanner.pos; var prevTokId = this.scanner.previousToken().tokenId; this.currentToken = this.scanner.scan(); var couldBeLambda = prevTokId == TypeScript.TokenID.OpenParen || prevTokId == TypeScript.TokenID.Comma || prevTokId == TypeScript.TokenID.EqualsEquals || prevTokId == TypeScript.TokenID.Colon; if(couldBeLambda && this.currentToken.tokenId == TypeScript.TokenID.CloseParen) { parseAsLambda = true; expectlambdaRParen = false; this.currentToken = this.scanner.scan(); } else { if(couldBeLambda && this.currentToken.tokenId == TypeScript.TokenID.DotDotDot) { parseAsLambda = true; expectlambdaRParen = true; } else { ast = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.RParen, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes, couldBeLambda); limChar = this.scanner.lastTokenLimChar(); parseAsLambda = couldBeLambda && (ast.nodeType == TypeScript.NodeType.Name || ast.nodeType == TypeScript.NodeType.Comma) && (this.currentToken.tokenId == TypeScript.TokenID.Colon || this.currentToken.tokenId == TypeScript.TokenID.Question); expectlambdaRParen = true; } } if((ast && !parseAsLambda)) { if(TypeScript.hasFlag(ast.flags, TypeScript.ASTFlags.SkipNextRParen)) { ast.flags = ast.flags & (~(TypeScript.ASTFlags.SkipNextRParen)); break; } this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet); ast.isParenthesized = true; } break; } case TypeScript.TokenID.NumberLiteral: { var numTok = this.currentToken; this.currentToken = this.scanner.scan(); ast = new TypeScript.NumberLiteral(numTok.value, numTok.hasEmptyFraction); ast.minChar = minChar; limChar = this.scanner.lastTokenLimChar(); break; } case TypeScript.TokenID.StringLiteral: { ast = new TypeScript.StringLiteral(this.currentToken.getText()); this.currentToken = this.scanner.scan(); ast.minChar = minChar; limChar = this.scanner.lastTokenLimChar(); break; } case TypeScript.TokenID.RegularExpressionLiteral: { var rtok = this.currentToken; ast = new TypeScript.RegexLiteral(rtok.regex); this.currentToken = this.scanner.scan(); ast.minChar = minChar; limChar = this.scanner.lastTokenLimChar(); break; } case TypeScript.TokenID.OpenBracket: { minChar = this.scanner.startPos; this.currentToken = this.scanner.scan(); ast = this.parseArrayLiteral(TypeScript.ErrorRecoverySet.RBrack | errorRecoverySet); ast.minChar = minChar; limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseBracket, errorRecoverySet); break; } case TypeScript.TokenID.OpenBrace: { minChar = this.scanner.startPos; this.currentToken = this.scanner.scan(); var members = this.parseMemberList(TypeScript.ErrorRecoverySet.RCurly | errorRecoverySet); this.checkCurrentToken(TypeScript.TokenID.CloseBrace, errorRecoverySet); ast = new TypeScript.UnaryExpression(TypeScript.NodeType.ObjectLit, members); ast.minChar = minChar; limChar = this.scanner.lastTokenLimChar(); members.minChar = minChar; members.limChar = limChar; break; } case TypeScript.TokenID.LessThan: { minChar = this.scanner.startPos; this.currentToken = this.scanner.scan(); var term = this.parseTypeReference(TypeScript.ErrorRecoverySet.BinOp, false); this.checkCurrentToken(TypeScript.TokenID.GreaterThan, errorRecoverySet); ast = new TypeScript.UnaryExpression(TypeScript.NodeType.TypeAssertion, this.parseExpr(errorRecoverySet, TypeScript.OperatorPrecedence.Unary, false, TypeContext.NoTypes)); (ast).castTerm = term; break; } default: { if(this.prevExpr && TypeScript.hasFlag(this.prevExpr.flags, TypeScript.ASTFlags.PossibleOptionalParameter)) { parseAsLambda = true; ast = this.prevExpr; } else { this.reportParseError("Check format of expression term"); if(this.errorRecovery) { var ident = new TypeScript.MissingIdentifier(); ident.minChar = minChar; ident.flags |= TypeScript.ASTFlags.Error; this.skip(errorRecoverySet | TypeScript.ErrorRecoverySet.Postfix); if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { ident.setText(this.currentToken.getText(), (this.currentToken).hasEscapeSequence); this.currentToken = this.scanner.scan(); limChar = this.scanner.lastTokenLimChar(); } else { limChar = this.scanner.lastTokenLimChar(); } ast = ident; } } } } } if(parseAsLambda) { if(this.currentToken.tokenId == TypeScript.TokenID.Colon || this.currentToken.tokenId == TypeScript.TokenID.Comma || this.currentToken.tokenId == TypeScript.TokenID.CloseParen || this.currentToken.tokenId == TypeScript.TokenID.DotDotDot) { ast = this.parseLambdaExpr(errorRecoverySet, ast, true, expectlambdaRParen); ast.minChar = minChar; limChar = this.scanner.lastTokenLimChar(); ast.limChar = limChar; } else { if(ast) { ast.isParenthesized = true; } } } if(sawId && (typeContext != TypeContext.NoTypes)) { typeContext |= TypeContext.ArraySuffix; } var postFix = this.parsePostfixOperators(errorRecoverySet, ast, allowCall, inNew, typeContext, minChar, limChar); if(postFix) { if(sawId && (postFix.nodeType == TypeScript.NodeType.Index)) { var binExpr = postFix; if(binExpr.operand2 == null) { postFix = this.convertToTypeReference(postFix); } } postFix.minChar = minChar; postFix.limChar = TypeScript.max(postFix.limChar, this.scanner.lastTokenLimChar()); return postFix; } else { return new TypeScript.AST(TypeScript.NodeType.Error); } }; Parser.prototype.parseLambdaExpr = function (errorRecoverySet, lambdaArgs, skipNextRParen, expectClosingRParen) { var ast = this.parseFncDecl(errorRecoverySet, false, false, false, null, false, false, false, TypeScript.Modifiers.None, { preProcessedLambdaArgs: lambdaArgs }, expectClosingRParen); (ast).fncFlags |= TypeScript.FncFlags.IsFunctionExpression; (ast).fncFlags |= TypeScript.FncFlags.IsFatArrowFunction; if(!skipNextRParen) { ast.flags |= TypeScript.ASTFlags.SkipNextRParen; } ast.limChar = this.scanner.lastTokenLimChar(); ; ; return ast; }; Parser.prototype.parseExpr = function (errorRecoverySet, minPrecedence, allowIn, typeContext, possiblyInLambda) { if (typeof possiblyInLambda === "undefined") { possiblyInLambda = false; } var ast = null; var tokenInfo = TypeScript.lookupToken(this.currentToken.tokenId); var canAssign = true; var idHint = null; var minChar = this.scanner.startPos; var preComments = this.parseComments(); var exprIsAnonLambda = false; if((tokenInfo != undefined) && (tokenInfo.unopNodeType != TypeScript.NodeType.None)) { canAssign = false; this.currentToken = this.scanner.scan(); var tempExpr = this.parseExpr(TypeScript.ErrorRecoverySet.BinOp | errorRecoverySet, tokenInfo.unopPrecedence, allowIn, TypeContext.NoTypes); if((tokenInfo.unopNodeType == TypeScript.NodeType.Pos) && (tempExpr.nodeType == TypeScript.NodeType.NumberLit)) { ast = tempExpr; } else { if((tokenInfo.unopNodeType == TypeScript.NodeType.Neg) && (tempExpr.nodeType == TypeScript.NodeType.NumberLit)) { var numLit = tempExpr; numLit.value = (-numLit.value); if(numLit.value == 0) { numLit.isNegativeZero = true; } ast = tempExpr; } else { ast = new TypeScript.UnaryExpression(tokenInfo.unopNodeType, tempExpr); ast.limChar = tempExpr.limChar; } } ast.minChar = minChar; } else { ast = this.parseTerm(TypeScript.ErrorRecoverySet.BinOp | TypeScript.ErrorRecoverySet.AddOp | errorRecoverySet, true, typeContext, false); var id; var temp; if(ast.nodeType == TypeScript.NodeType.Name) { id = ast; idHint = id.actualText; } else { if(ast.nodeType == TypeScript.NodeType.Dot) { var subsumedExpr = false; if(this.inferPropertiesFromThisAssignment && (this.currentToken.tokenId == TypeScript.TokenID.Colon || this.currentToken.tokenId == TypeScript.TokenID.Equals) && this.parsingClassConstructorDefinition && this.nestingLevel == this.currentClassDefinition.constructorNestingLevel && (ast).operand1.nodeType == TypeScript.NodeType.This) { if((ast).operand2.nodeType == TypeScript.NodeType.Name) { var op2ID = ((ast).operand2); if(!this.currentClassDefinition.knownMemberNames[op2ID.actualText]) { ast = this.parseClassMemberVariableDeclaration(op2ID, ast.minChar, true, errorRecoverySet, TypeScript.Modifiers.Public); subsumedExpr = true; } } } if(!subsumedExpr) { temp = ast; while(temp.nodeType == TypeScript.NodeType.Dot) { var binExpr = temp; temp = binExpr.operand2; } if(temp.nodeType == TypeScript.NodeType.Name) { id = temp; idHint = id.actualText; } } } } if((!this.scanner.lastTokenHadNewline()) && ((this.currentToken.tokenId == TypeScript.TokenID.PlusPlus) || (this.currentToken.tokenId == TypeScript.TokenID.MinusMinus))) { canAssign = false; var operand = ast; ast = new TypeScript.UnaryExpression((this.currentToken.tokenId == TypeScript.TokenID.PlusPlus) ? TypeScript.NodeType.IncPost : TypeScript.NodeType.DecPost, operand); ast.limChar = this.scanner.pos; ast.minChar = operand.minChar; this.currentToken = this.scanner.scan(); } } for(; ; ) { tokenInfo = TypeScript.lookupToken(this.currentToken.tokenId); if((tokenInfo == undefined) || (tokenInfo.binopNodeType == TypeScript.NodeType.None)) { break; } if((!allowIn) && (tokenInfo.binopNodeType == TypeScript.NodeType.In)) { break; } if(tokenInfo.binopPrecedence == TypeScript.OperatorPrecedence.Assignment) { if(tokenInfo.binopPrecedence < minPrecedence) { break; } if(!canAssign) { this.reportParseError("illegal assignment"); } } else { if(tokenInfo.binopPrecedence <= minPrecedence) { break; } } if(possiblyInLambda && this.currentToken.tokenId == TypeScript.TokenID.Comma && this.scanner.getLookAheadToken().tokenId == TypeScript.TokenID.DotDotDot) { exprIsAnonLambda = true; canAssign = false; ast = this.parseLambdaExpr(errorRecoverySet, ast, false, true); break; } this.currentToken = this.scanner.scan(); canAssign = false; if(tokenInfo.binopNodeType == TypeScript.NodeType.ConditionalExpression) { if(possiblyInLambda && (this.currentToken.tokenId == TypeScript.TokenID.Equals || this.currentToken.tokenId == TypeScript.TokenID.Colon || this.currentToken.tokenId == TypeScript.TokenID.CloseParen || this.currentToken.tokenId == TypeScript.TokenID.Comma)) { exprIsAnonLambda = true; canAssign = true; } else { this.prevExpr = ast; var whenTrue = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.Colon, TypeScript.OperatorPrecedence.Assignment, allowIn, TypeContext.NoTypes); this.prevExpr = null; this.checkCurrentToken(TypeScript.TokenID.Colon, errorRecoverySet | TypeScript.ErrorRecoverySet.ExprStart); var whenFalse = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.BinOp, TypeScript.OperatorPrecedence.Assignment, allowIn, TypeContext.NoTypes); ast = new TypeScript.ConditionalExpression(ast, whenTrue, whenFalse); } } else { var tc = TypeContext.NoTypes; var binExpr2; binExpr2 = new TypeScript.BinaryExpression(tokenInfo.binopNodeType, ast, this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.BinOp, tokenInfo.binopPrecedence, allowIn, TypeContext.NoTypes, possiblyInLambda)); if(binExpr2.operand2.nodeType == TypeScript.NodeType.FuncDecl) { var funcDecl = binExpr2.operand2; funcDecl.hint = idHint; } binExpr2.minChar = ast.minChar; binExpr2.limChar = this.scanner.lastTokenLimChar(); idHint = null; ast = binExpr2; } } if(canAssign) { ast.flags |= TypeScript.ASTFlags.Writeable; } if(!exprIsAnonLambda) { ast.minChar = minChar; ast.limChar = TypeScript.max(ast.limChar, this.scanner.lastTokenLimChar()); ast.preComments = preComments; ast.postComments = this.parseCommentsForLine(this.scanner.line); } return ast; }; Parser.prototype.parsePostfixOperators = function (errorRecoverySet, ast, allowCall, inNew, typeContext, lhsMinChar, lhsLimChar) { var count = 0; if(!ast) { ast = new TypeScript.AST(TypeScript.NodeType.EmptyExpr); ast.isParenthesized = true; } ast.minChar = lhsMinChar; ast.limChar = lhsLimChar; for(; ; ) { switch(this.currentToken.tokenId) { case TypeScript.TokenID.OpenParen: { if(inNew) { var callExpr = ast; callExpr.arguments = this.parseArgList(errorRecoverySet); inNew = false; } else { if(!allowCall) { return ast; } ast = new TypeScript.CallExpression(TypeScript.NodeType.Call, ast, this.parseArgList(errorRecoverySet)); ast.minChar = lhsMinChar; } ast.limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet); break; } case TypeScript.TokenID.OpenBracket: { this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.CloseBracket) { if(TypeScript.hasFlag(typeContext, TypeContext.ArraySuffix)) { this.currentToken = this.scanner.scan(); if(ast.nodeType == TypeScript.NodeType.TypeRef) { var typeRef = ast; typeRef.arrayCount++; } else { ast = new TypeScript.BinaryExpression(TypeScript.NodeType.Index, ast, null); } ast.limChar = this.scanner.pos; break; } } ast = new TypeScript.BinaryExpression(TypeScript.NodeType.Index, ast, this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.RBrack, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes)); ast.minChar = lhsMinChar; ast.limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseBracket, errorRecoverySet); break; } case TypeScript.TokenID.Dot: { var name = null; var curpos = this.scanner.pos; this.currentToken = this.scanner.scan(); if (this.currentToken === undefined) { this.currentToken = this.scanner.scan(); continue; } if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || ((!this.errorRecovery || !this.scanner.lastTokenHadNewline()) && TypeScript.convertTokToIDName(this.currentToken))) { ast.flags |= TypeScript.ASTFlags.DotLHS; name = this.createRef(this.currentToken.getText(), (this.currentToken).hasEscapeSequence, this.scanner.startPos); name.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); } else { this.reportParseError("Expected identifier following dot"); if(this.errorRecovery) { this.skip(errorRecoverySet); ast.flags |= (TypeScript.ASTFlags.Error | TypeScript.ASTFlags.DotLHS); return ast; } else { name = new TypeScript.MissingIdentifier(); } } ast = new TypeScript.BinaryExpression(TypeScript.NodeType.Dot, ast, name); ast.minChar = lhsMinChar; ast.limChar = this.scanner.lastTokenLimChar(); break; } case TypeScript.TokenID.EqualsGreaterThan: { ast = this.parseFncDecl(errorRecoverySet, false, false, false, null, false, false, false, TypeScript.Modifiers.None, { preProcessedLambdaArgs: ast }, false); (ast).fncFlags |= TypeScript.FncFlags.IsFunctionExpression; ast.minChar = lhsMinChar; ast.limChar = this.scanner.lastTokenLimChar(); break; } default: { return ast; } } } }; Parser.prototype.parseTry = function (tryNode, errorRecoverySet, parentModifiers) { var minChar = this.scanner.startPos; var preComments = this.parseComments(); this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId != TypeScript.TokenID.OpenBrace) { this.reportParseError("Expected '{'"); if(this.errorRecovery) { var etryNode = tryNode; etryNode.minChar = minChar; etryNode.limChar = this.scanner.lastTokenLimChar(); etryNode.flags |= TypeScript.ASTFlags.Error; return etryNode; } } tryNode.body = this.parseStatement(errorRecoverySet, TypeScript.AllowedElements.None, parentModifiers); tryNode.minChar = minChar; tryNode.limChar = tryNode.body.limChar; tryNode.preComments = preComments; tryNode.postComments = this.parseComments(); return tryNode; }; Parser.prototype.parseCatch = function (errorRecoverySet, parentModifiers) { var catchMinChar = this.scanner.startPos; var preComments = this.parseComments(); this.currentToken = this.scanner.scan(); this.checkCurrentToken(TypeScript.TokenID.OpenParen, errorRecoverySet | TypeScript.ErrorRecoverySet.ExprStart); if((this.currentToken.tokenId != TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { this.reportParseError("Expected identifier in catch header"); if(this.errorRecovery) { this.skip(errorRecoverySet); var ecatch = new TypeScript.Catch(new TypeScript.VarDecl(new TypeScript.MissingIdentifier(), this.nestingLevel), new TypeScript.Statement(TypeScript.NodeType.Empty)); ecatch.statement.minChar = catchMinChar; ecatch.statement.limChar = this.scanner.pos; ecatch.minChar = this.scanner.startPos; ecatch.limChar = this.scanner.pos; ecatch.flags |= TypeScript.ASTFlags.Error; return ecatch; } } var param = new TypeScript.VarDecl(TypeScript.Identifier.fromToken(this.currentToken), this.nestingLevel); param.id.minChar = this.scanner.startPos; param.id.limChar = this.scanner.pos; param.minChar = param.id.minChar; param.limChar = param.id.limChar; this.currentToken = this.scanner.scan(); var statementPos = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet | TypeScript.ErrorRecoverySet.StmtStart); if(this.currentToken.tokenId != TypeScript.TokenID.OpenBrace) { this.reportParseError("Expected '{' to start catch body"); if(this.errorRecovery) { this.skip(errorRecoverySet); var ecatch = new TypeScript.Catch(new TypeScript.VarDecl(new TypeScript.MissingIdentifier(), this.nestingLevel), new TypeScript.Statement(TypeScript.NodeType.Empty)); ecatch.statement.minChar = catchMinChar; ecatch.statement.limChar = statementPos; ecatch.minChar = this.scanner.startPos; ecatch.limChar = this.scanner.pos; ecatch.flags |= TypeScript.ASTFlags.Error; return ecatch; } } var catchStmt = this.parseStatement(errorRecoverySet, TypeScript.AllowedElements.None, parentModifiers); var catchNode = new TypeScript.Catch(param, catchStmt); catchNode.statement.minChar = catchMinChar; catchNode.statement.limChar = statementPos; catchNode.minChar = catchMinChar; catchNode.limChar = catchStmt.limChar; catchNode.preComments = preComments; catchNode.postComments = this.parseComments(); return catchNode; }; Parser.prototype.parseFinally = function (errorRecoverySet, parentModifiers) { var finMinChar = this.scanner.startPos; var preComments = this.parseComments(); this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId != TypeScript.TokenID.OpenBrace) { this.reportParseError("Expected '{' to start body of finally statement"); if(this.errorRecovery) { this.skip(errorRecoverySet); var efin = new TypeScript.Finally(new TypeScript.Statement(TypeScript.NodeType.Empty)); efin.flags |= TypeScript.ASTFlags.Error; efin.minChar = this.scanner.startPos; efin.limChar = this.scanner.pos; return efin; } } var finBody = this.parseStatement(errorRecoverySet, TypeScript.AllowedElements.None, parentModifiers); var fin = new TypeScript.Finally(finBody); fin.minChar = finMinChar; fin.limChar = fin.body.limChar; fin.preComments = preComments; fin.postComments = this.parseComments(); return fin; }; Parser.prototype.parseTryCatchFinally = function (errorRecoverySet, parentModifiers, labelList) { var tryPart = new TypeScript.Try(null); var tryMinChar = this.scanner.startPos; this.pushStmt(tryPart, labelList); this.parseTry(tryPart, errorRecoverySet | TypeScript.ErrorRecoverySet.Catch, parentModifiers); this.popStmt(); var tc = null; var tf = null; if(this.currentToken.tokenId == TypeScript.TokenID.Catch) { var catchPart = this.parseCatch(errorRecoverySet | TypeScript.ErrorRecoverySet.Catch, parentModifiers); tc = new TypeScript.TryCatch(tryPart, catchPart); tc.minChar = tryPart.minChar; tc.limChar = catchPart.limChar; } if(this.currentToken.tokenId != TypeScript.TokenID.Finally) { if(tc == null) { this.reportParseError("try with neither catch nor finally"); if(this.errorRecovery) { var etf = new TypeScript.TryFinally(tryPart, new TypeScript.Finally(new TypeScript.AST(TypeScript.NodeType.Empty))); etf.flags |= TypeScript.ASTFlags.Error; etf.minChar = this.scanner.startPos; etf.limChar = this.scanner.pos; return etf; } return new TypeScript.TryFinally(tryPart, new TypeScript.Finally(new TypeScript.AST(TypeScript.NodeType.Empty))); } else { return tc; } } else { if(tc) { tryPart = tc; } var finallyPart = this.parseFinally(errorRecoverySet, parentModifiers); tf = new TypeScript.TryFinally(tryPart, finallyPart); tf.minChar = tryMinChar; tf.limChar = finallyPart.limChar; return tf; } }; Parser.prototype.parseStatement = function (errorRecoverySet, allowedElements, parentModifiers) { var ast = null; var labelList = null; var astList = null; var temp; var modifiers = TypeScript.Modifiers.None; var minChar = this.scanner.startPos; var forInOk = false; var needTerminator = false; var fnOrVar = null; var preComments = this.parseComments(); this.state = ParseState.StartStatement; function isAmbient() { return TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient) || TypeScript.hasFlag(parentModifiers, TypeScript.Modifiers.Ambient); } function mayNotBeExported() { if(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported)) { this.reportError("Statement may not be exported"); } } for(; ; ) { switch(this.currentToken.tokenId) { case TypeScript.TokenID.EndOfFile: { ast = new TypeScript.AST(TypeScript.NodeType.Error); ast.minChar = minChar; ast.limChar = this.scanner.pos; break; } case TypeScript.TokenID.Function: { if(this.parsingDeclareFile || isAmbient() || this.ambientModule) { this.currentToken = this.scanner.scan(); fnOrVar = this.parsePropertyDeclaration(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon, modifiers, true, false); if(fnOrVar.nodeType == TypeScript.NodeType.VarDecl) { this.reportParseError("function keyword can only introduce function declaration"); } else { if((fnOrVar.nodeType == TypeScript.NodeType.FuncDecl) && ((fnOrVar).fncFlags , TypeScript.FncFlags.IsFatArrowFunction)) { needTerminator = true; } } ast = fnOrVar; if(this.parsingDeclareFile || this.ambientModule && ast.nodeType == TypeScript.NodeType.FuncDecl) { (ast).fncFlags |= TypeScript.FncFlags.Exported; } } else { ast = this.parseFncDecl(errorRecoverySet, true, false, false, null, false, false, isAmbient(), modifiers, null, true); if(TypeScript.hasFlag((ast).fncFlags, TypeScript.FncFlags.IsFatArrowFunction)) { needTerminator = true; } if(this.ambientModule) { this.reportParseError("function declaration not permitted within ambient module"); } if(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported)) { (ast).fncFlags |= TypeScript.FncFlags.Exported; } } break; } case TypeScript.TokenID.Module: { if((allowedElements & TypeScript.AllowedElements.ModuleDeclarations) == TypeScript.AllowedElements.None) { this.reportParseError("module not allowed in this context"); this.currentToken = this.scanner.scan(); ast = new TypeScript.AST(TypeScript.NodeType.Error); ast.minChar = minChar; ast.limChar = this.scanner.lastTokenLimChar(); } else { ast = this.parseModuleDecl(errorRecoverySet, modifiers, preComments); preComments = null; } break; } case TypeScript.TokenID.Import: { if((allowedElements & TypeScript.AllowedElements.ModuleDeclarations) == TypeScript.AllowedElements.None) { this.reportParseError("module not allowed in this context"); this.currentToken = this.scanner.scan(); ast = new TypeScript.AST(TypeScript.NodeType.Error); ast.minChar = minChar; ast.limChar = this.scanner.lastTokenLimChar(); } else { if(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported)) { this.reportParseError("export keyword not permitted on import declaration"); } ast = this.parseImportDeclaration(errorRecoverySet, modifiers); needTerminator = true; } break; } case TypeScript.TokenID.Export: { if((allowedElements & TypeScript.AllowedElements.ModuleDeclarations) == TypeScript.AllowedElements.None) { this.reportParseError("'export' statements are only allowed at the global and module levels"); this.currentToken = this.scanner.scan(); ast = new TypeScript.AST(TypeScript.NodeType.Error); ast.minChar = minChar; ast.limChar = this.scanner.lastTokenLimChar(); } if(this.topLevel) { this.hasTopLevelImportOrExport = true; } modifiers |= TypeScript.Modifiers.Exported; this.currentToken = this.scanner.scan(); break; } case TypeScript.TokenID.Private: { modifiers |= TypeScript.Modifiers.Private; this.currentToken = this.scanner.scan(); if(this.parsingClassConstructorDefinition) { if(!this.inferPropertiesFromThisAssignment) { this.reportParseError("Property declarations are not permitted within constructor bodies"); } minChar = this.scanner.pos; if(this.inferPropertiesFromThisAssignment && (this.currentToken.tokenId != TypeScript.TokenID.This || (this.currentToken = this.scanner.scan()).tokenId != TypeScript.TokenID.Dot)) { this.reportParseError("Expected 'this.' for property declaration"); this.currentToken = this.scanner.scan(); ast = new TypeScript.AST(TypeScript.NodeType.Error); ast.minChar = minChar; ast.limChar = this.scanner.lastTokenLimChar(); } else { this.currentToken = this.scanner.scan(); var id = TypeScript.Identifier.fromToken(this.currentToken); id.minChar = this.scanner.startPos; id.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); ast = this.parseClassMemberVariableDeclaration(id, minChar, this.parsingClassConstructorDefinition, errorRecoverySet, modifiers); } } else { if(this.currentToken.tokenId != TypeScript.TokenID.Interface) { if(this.currentToken.tokenId == TypeScript.TokenID.Get) { this.prevIDTok = this.currentToken; this.currentToken = this.scanner.scan(); if(TypeScript.codeGenTarget < TypeScript.CodeGenTarget.ES5) { this.reportParseError("Property accessors are only available when targeting ES5 or greater"); } if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { modifiers |= TypeScript.Modifiers.Getter; this.prevIDTok = null; } } else { if(this.currentToken.tokenId == TypeScript.TokenID.Set) { this.prevIDTok = this.currentToken; this.currentToken = this.scanner.scan(); if(TypeScript.codeGenTarget < TypeScript.CodeGenTarget.ES5) { this.reportParseError("Property accessors are only available when targeting ES5 or greater"); } if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { modifiers |= TypeScript.Modifiers.Setter; this.prevIDTok = null; } } } fnOrVar = this.parsePropertyDeclaration(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon, modifiers, isAmbient(), false); if((fnOrVar.nodeType == TypeScript.NodeType.VarDecl) || ((fnOrVar.nodeType == TypeScript.NodeType.FuncDecl) && (TypeScript.hasFlag((fnOrVar).fncFlags, TypeScript.FncFlags.IsFatArrowFunction)))) { needTerminator = true; } ast = fnOrVar; } } break; } case TypeScript.TokenID.Public: { if(this.parsingClassConstructorDefinition) { if(!this.inferPropertiesFromThisAssignment) { this.reportParseError("Property declarations are not permitted within constructor bodies"); } this.currentToken = this.scanner.scan(); minChar = this.scanner.pos; modifiers |= TypeScript.Modifiers.Public; if(this.inferPropertiesFromThisAssignment && (this.currentToken.tokenId != TypeScript.TokenID.This || (this.currentToken = this.scanner.scan()).tokenId != TypeScript.TokenID.Dot)) { this.reportParseError("Expected 'this.' for property declaration"); this.currentToken = this.scanner.scan(); ast = new TypeScript.AST(TypeScript.NodeType.Error); ast.minChar = minChar; ast.limChar = this.scanner.lastTokenLimChar(); } else { this.currentToken = this.scanner.scan(); var id = TypeScript.Identifier.fromToken(this.currentToken); id.minChar = this.scanner.startPos; id.limChar = this.scanner.pos; this.currentToken = this.scanner.scan(); ast = this.parseClassMemberVariableDeclaration(id, minChar, this.parsingClassConstructorDefinition, errorRecoverySet, modifiers); } } else { if((allowedElements & TypeScript.AllowedElements.Properties) == TypeScript.AllowedElements.None) { this.reportParseError("'property' statements are only allowed within classes"); this.currentToken = this.scanner.scan(); ast = new TypeScript.AST(TypeScript.NodeType.Error); ast.minChar = minChar; ast.limChar = this.scanner.lastTokenLimChar(); } else { modifiers |= TypeScript.Modifiers.Public; this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.Get) { this.prevIDTok = this.currentToken; this.currentToken = this.scanner.scan(); if(TypeScript.codeGenTarget < TypeScript.CodeGenTarget.ES5) { this.reportParseError("Property accessors are only available when targeting ES5 or greater"); } if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { modifiers |= TypeScript.Modifiers.Getter; this.prevIDTok = null; } } else { if(this.currentToken.tokenId == TypeScript.TokenID.Set) { this.prevIDTok = this.currentToken; this.currentToken = this.scanner.scan(); if(TypeScript.codeGenTarget < TypeScript.CodeGenTarget.ES5) { this.reportParseError("Property accessors are only available when targeting ES5 or greater"); } if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { modifiers |= TypeScript.Modifiers.Setter; this.prevIDTok = null; } } } fnOrVar = this.parsePropertyDeclaration(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon, modifiers, isAmbient(), false); if((fnOrVar.nodeType == TypeScript.NodeType.VarDecl) || ((fnOrVar.nodeType == TypeScript.NodeType.FuncDecl) && TypeScript.hasFlag((fnOrVar).fncFlags, TypeScript.FncFlags.IsFatArrowFunction))) { needTerminator = true; } ast = fnOrVar; } } break; } case TypeScript.TokenID.Declare: { if(!(allowedElements & TypeScript.AllowedElements.AmbientDeclarations)) { this.reportParseError("Ambient declarations are only allowed at the top-level or module scopes"); } if(!this.parsingDeclareFile && TypeScript.hasFlag(parentModifiers, TypeScript.Modifiers.Ambient)) { this.reportParseError("Duplicate ambient declaration in this context. (Is the enclosing module or class already ambient?)"); } modifiers |= TypeScript.Modifiers.Ambient; this.currentToken = this.scanner.scan(); break; } case TypeScript.TokenID.Class: { if((allowedElements & TypeScript.AllowedElements.ClassDeclarations) == TypeScript.AllowedElements.None) { this.reportParseError("class not allowed in this context"); this.currentToken = this.scanner.scan(); ast = new TypeScript.AST(TypeScript.NodeType.Error); ast.minChar = minChar; ast.limChar = this.scanner.lastTokenLimChar(); } else { ast = this.parseClassDecl(errorRecoverySet, minChar, modifiers); } break; } case TypeScript.TokenID.Interface: { if((allowedElements & TypeScript.AllowedElements.InterfaceDeclarations) == TypeScript.AllowedElements.None) { this.reportParseError("interface not allowed in this context"); this.currentToken = this.scanner.scan(); ast = new TypeScript.AST(TypeScript.NodeType.Error); ast.minChar = minChar; ast.limChar = this.scanner.lastTokenLimChar(); } else { ast = this.parseInterfaceDecl(errorRecoverySet, modifiers); } break; } case TypeScript.TokenID.Var: { var declAst = this.parseVariableDeclaration(errorRecoverySet | TypeScript.ErrorRecoverySet.StmtStart, modifiers, true, false); if(declAst.nodeType == TypeScript.NodeType.VarDecl) { ast = declAst; } else { ast = new TypeScript.Block(declAst, false); } needTerminator = true; break; } case TypeScript.TokenID.Static: { if(this.currentClassDecl == null) { this.reportParseError("Statics may only be class members"); } mayNotBeExported(); modifiers |= TypeScript.Modifiers.Public; this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.Get) { this.prevIDTok = this.currentToken; this.currentToken = this.scanner.scan(); if(TypeScript.codeGenTarget < TypeScript.CodeGenTarget.ES5) { this.reportParseError("Property accessors are only available when targeting ES5 or greater"); } if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { modifiers |= TypeScript.Modifiers.Getter; this.prevIDTok = null; } } else { if(this.currentToken.tokenId == TypeScript.TokenID.Set) { this.currentToken = this.scanner.scan(); if(TypeScript.codeGenTarget < TypeScript.CodeGenTarget.ES5) { this.reportParseError("Property accessors are only available when targeting ES5 or greater"); } if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) || TypeScript.convertTokToID(this.currentToken, this.strictMode)) { modifiers |= TypeScript.Modifiers.Setter; } } } if(isAmbient()) { modifiers |= TypeScript.Modifiers.Ambient; } fnOrVar = this.parsePropertyDeclaration(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon, modifiers, this.parsingDeclareFile || (modifiers & TypeScript.Modifiers.Ambient) != TypeScript.Modifiers.None, true); var staticsList = this.topStaticsList(); if(staticsList && fnOrVar.nodeType == TypeScript.NodeType.VarDecl) { staticsList.append(fnOrVar); } if(fnOrVar.nodeType == TypeScript.NodeType.VarDecl || ((fnOrVar.nodeType == TypeScript.NodeType.FuncDecl) && TypeScript.hasFlag((fnOrVar).fncFlags, TypeScript.FncFlags.IsFatArrowFunction))) { needTerminator = true; } ast = fnOrVar; break; } case TypeScript.TokenID.For: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("syntax error: for statement does not take modifiers"); } minChar = this.scanner.startPos; this.checkNextToken(TypeScript.TokenID.OpenParen, errorRecoverySet | TypeScript.ErrorRecoverySet.ExprStart | TypeScript.ErrorRecoverySet.Var); this.state = ParseState.ForInit; forInOk = true; switch(this.currentToken.tokenId) { case TypeScript.TokenID.Var: { temp = this.parseVariableDeclaration(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon | TypeScript.ErrorRecoverySet.In, TypeScript.Modifiers.None, false, false); break; } case TypeScript.TokenID.Semicolon: { temp = null; this.state = ParseState.ForCondStart; break; } default: { temp = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon | TypeScript.ErrorRecoverySet.In, TypeScript.OperatorPrecedence.None, false, TypeContext.NoTypes); break; } } this.state = ParseState.ForInitAfterVar; if(this.currentToken.tokenId == TypeScript.TokenID.In) { if((temp == null) || (!forInOk)) { this.reportParseError("malformed for statement"); if(this.errorRecovery) { this.skip(errorRecoverySet | TypeScript.ErrorRecoverySet.StmtStart); ast = new TypeScript.AST(TypeScript.NodeType.Empty); ast.flags |= TypeScript.ASTFlags.Error; } } else { this.currentToken = this.scanner.scan(); var forInStmt = new TypeScript.ForInStatement(temp, this.parseExpr(TypeScript.ErrorRecoverySet.RParen | errorRecoverySet, TypeScript.OperatorPrecedence.Comma, false, TypeContext.NoTypes)); forInStmt.limChar = this.scanner.pos; forInStmt.statement.minChar = minChar; forInStmt.statement.limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseParen, TypeScript.ErrorRecoverySet.StmtStart | errorRecoverySet); this.pushStmt(forInStmt, labelList); forInStmt.body = this.parseStatement(errorRecoverySet, allowedElements, parentModifiers); this.popStmt(); forInStmt.minChar = minChar; ast = forInStmt; } } else { var forStmt = new TypeScript.ForStatement(temp); forStmt.minChar = minChar; this.checkCurrentToken(TypeScript.TokenID.Semicolon, errorRecoverySet); if(this.currentToken.tokenId == TypeScript.TokenID.Semicolon) { forStmt.cond = null; } else { forStmt.cond = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon | TypeScript.ErrorRecoverySet.RParen, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes); if(this.currentToken.tokenId != TypeScript.TokenID.Semicolon) { this.skip(errorRecoverySet | TypeScript.ErrorRecoverySet.StmtStart); ast = forStmt; ast.flags |= TypeScript.ASTFlags.Error; } } this.currentToken = this.scanner.scan(); if(this.currentToken.tokenId == TypeScript.TokenID.CloseParen) { forStmt.incr = null; } else { forStmt.incr = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon | TypeScript.ErrorRecoverySet.RParen, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes); } this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet | TypeScript.ErrorRecoverySet.LCurly); this.pushStmt(forStmt, labelList); forStmt.body = this.parseStatement(errorRecoverySet, allowedElements, parentModifiers); this.popStmt(); forStmt.limChar = forStmt.body.limChar; ast = forStmt; } break; } case TypeScript.TokenID.With: { { if(TypeScript.codeGenTarget < TypeScript.CodeGenTarget.ES5) { this.reportParseError("'with' statements are only available in ES5 codegen mode or better"); } if(this.strictMode) { this.reportParseError("'with' statements are not available in strict mode"); } mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("'with' statement does not take modifiers"); } minChar = this.scanner.startPos; this.checkNextToken(TypeScript.TokenID.OpenParen, errorRecoverySet | TypeScript.ErrorRecoverySet.ExprStart | TypeScript.ErrorRecoverySet.Var); var expr = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.Colon, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes); this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet | TypeScript.ErrorRecoverySet.LCurly); var withStmt = new TypeScript.WithStatement(expr); withStmt.body = this.parseStatement(errorRecoverySet, allowedElements, parentModifiers); withStmt.minChar = minChar; withStmt.limChar = withStmt.body.limChar; ast = withStmt; } break; } case TypeScript.TokenID.Switch: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("'switch' statement does not take modifiers"); } this.checkNextToken(TypeScript.TokenID.OpenParen, errorRecoverySet | TypeScript.ErrorRecoverySet.ExprStart); var switchStmt = new TypeScript.SwitchStatement(this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.RParen, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes)); switchStmt.statement.minChar = minChar; switchStmt.statement.limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet | TypeScript.ErrorRecoverySet.LCurly); var caseListMinChar = this.scanner.startPos; this.checkCurrentToken(TypeScript.TokenID.OpenBrace, errorRecoverySet | TypeScript.ErrorRecoverySet.SCase); switchStmt.defaultCase = null; switchStmt.caseList = new TypeScript.ASTList(); var caseStmt = null; this.pushStmt(switchStmt, labelList); for(; ; ) { if((this.currentToken.tokenId == TypeScript.TokenID.Case) || (this.currentToken.tokenId == TypeScript.TokenID.Default)) { var isDefault = (this.currentToken.tokenId == TypeScript.TokenID.Default); caseStmt = new TypeScript.CaseStatement(); caseStmt.minChar = this.scanner.startPos; this.currentToken = this.scanner.scan(); if(isDefault) { switchStmt.defaultCase = caseStmt; } else { caseStmt.expr = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.Colon, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes); } this.checkCurrentToken(TypeScript.TokenID.Colon, errorRecoverySet | TypeScript.ErrorRecoverySet.StmtStart); caseStmt.body = new TypeScript.ASTList(); this.parseStatementList(errorRecoverySet | TypeScript.ErrorRecoverySet.RCurly, caseStmt.body, false, true, allowedElements, modifiers); caseStmt.limChar = caseStmt.body.limChar; switchStmt.caseList.append(caseStmt); } else { break; } } switchStmt.caseList.minChar = caseListMinChar; switchStmt.caseList.limChar = this.scanner.pos; switchStmt.limChar = switchStmt.caseList.limChar; this.checkCurrentToken(TypeScript.TokenID.CloseBrace, errorRecoverySet); this.popStmt(); ast = switchStmt; break; } case TypeScript.TokenID.While: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("'while' statement does not take modifiers"); } minChar = this.scanner.startPos; this.checkNextToken(TypeScript.TokenID.OpenParen, TypeScript.ErrorRecoverySet.ExprStart | errorRecoverySet); var whileStmt = new TypeScript.WhileStatement(this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.RParen, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes)); whileStmt.minChar = minChar; this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet | TypeScript.ErrorRecoverySet.StmtStart); this.pushStmt(whileStmt, labelList); whileStmt.body = this.parseStatement(errorRecoverySet, allowedElements, parentModifiers); whileStmt.limChar = whileStmt.body.limChar; this.popStmt(); ast = whileStmt; break; } case TypeScript.TokenID.Do: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("'do' statement does not take modifiers"); } minChar = this.scanner.startPos; this.currentToken = this.scanner.scan(); var doStmt = new TypeScript.DoWhileStatement(); doStmt.minChar = minChar; this.pushStmt(doStmt, labelList); doStmt.body = this.parseStatement(errorRecoverySet | TypeScript.ErrorRecoverySet.While, allowedElements, parentModifiers); this.popStmt(); doStmt.whileAST = new TypeScript.Identifier("while"); doStmt.whileAST.minChar = this.scanner.startPos; this.checkCurrentToken(TypeScript.TokenID.While, errorRecoverySet | TypeScript.ErrorRecoverySet.LParen); doStmt.whileAST.limChar = doStmt.whileAST.minChar + 5; this.checkCurrentToken(TypeScript.TokenID.OpenParen, errorRecoverySet | TypeScript.ErrorRecoverySet.ExprStart); doStmt.cond = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.RParen, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes); doStmt.limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet); ast = doStmt; if(this.currentToken.tokenId == TypeScript.TokenID.Semicolon) { this.currentToken = this.scanner.scan(); } break; } case TypeScript.TokenID.If: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("if statement does not take modifiers"); } minChar = this.scanner.startPos; this.checkNextToken(TypeScript.TokenID.OpenParen, errorRecoverySet | TypeScript.ErrorRecoverySet.ExprStart); var ifStmt = new TypeScript.IfStatement(this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.LParen, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes)); ifStmt.minChar = minChar; ifStmt.statement.minChar = minChar; ifStmt.statement.limChar = this.scanner.pos; this.checkCurrentToken(TypeScript.TokenID.CloseParen, errorRecoverySet | TypeScript.ErrorRecoverySet.StmtStart); this.pushStmt(ifStmt, labelList); ifStmt.thenBod = this.parseStatement(TypeScript.ErrorRecoverySet.Else | errorRecoverySet, allowedElements, parentModifiers); ifStmt.limChar = ifStmt.thenBod.limChar; if(this.currentToken.tokenId == TypeScript.TokenID.Else) { this.currentToken = this.scanner.scan(); ifStmt.elseBod = this.parseStatement(errorRecoverySet, allowedElements, parentModifiers); ifStmt.limChar = ifStmt.elseBod.limChar; } this.popStmt(); ast = ifStmt; break; } case TypeScript.TokenID.Try: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("try statement does not take modifiers"); } minChar = this.scanner.startPos; ast = this.parseTryCatchFinally(errorRecoverySet, parentModifiers, labelList); break; } case TypeScript.TokenID.OpenBrace: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("block does not take modifiers"); } minChar = this.scanner.startPos; this.currentToken = this.scanner.scan(); var block = new TypeScript.Block(new TypeScript.ASTList(), true); this.pushStmt(block, labelList); this.parseStatementList(errorRecoverySet | TypeScript.ErrorRecoverySet.RCurly, block.statements, false, false, TypeScript.AllowedElements.None, modifiers); this.popStmt(); block.statements.minChar = minChar; block.statements.limChar = this.scanner.pos; block.minChar = block.statements.minChar; block.limChar = block.statements.limChar; this.checkCurrentToken(TypeScript.TokenID.CloseBrace, errorRecoverySet); ast = block; break; } case TypeScript.TokenID.Semicolon: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("modifier can not appear here"); } ast = new TypeScript.AST(TypeScript.NodeType.Empty); this.currentToken = this.scanner.scan(); break; } case TypeScript.TokenID.Break: case TypeScript.TokenID.Continue: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("modifiers can not appear before jump statement"); } var jump = new TypeScript.Jump((this.currentToken.tokenId == TypeScript.TokenID.Break) ? TypeScript.NodeType.Break : TypeScript.NodeType.Continue); this.currentToken = this.scanner.scan(); if((this.currentToken.tokenId == TypeScript.TokenID.Identifier) && (!this.scanner.lastTokenHadNewline())) { jump.target = this.currentToken.getText(); this.currentToken = this.scanner.scan(); } this.resolveJumpTarget(jump); ast = jump; needTerminator = true; break; } case TypeScript.TokenID.Return: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("modifiers can not appear before return statement"); } if(!this.inFunction) { this.reportParseError("return statement outside of function body"); } minChar = this.scanner.startPos; this.currentToken = this.scanner.scan(); var retStmt = new TypeScript.ReturnStatement(); retStmt.minChar = minChar; if((this.currentToken.tokenId != TypeScript.TokenID.Semicolon) && (this.currentToken.tokenId != TypeScript.TokenID.CloseBrace) && (!(this.scanner.lastTokenHadNewline()))) { retStmt.returnExpression = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes); } needTerminator = true; retStmt.limChar = this.scanner.lastTokenLimChar(); ast = retStmt; break; } case TypeScript.TokenID.Throw: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("modifiers can not appear before a throw statement"); } minChar = this.scanner.startPos; this.currentToken = this.scanner.scan(); if((this.currentToken.tokenId != TypeScript.TokenID.Semicolon) && (this.currentToken.tokenId != TypeScript.TokenID.CloseBrace) && (!(this.scanner.lastTokenHadNewline()))) { temp = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes); } else { this.reportParseError("throw with no target"); temp = null; } ast = new TypeScript.UnaryExpression(TypeScript.NodeType.Throw, temp); ast.limChar = this.scanner.lastTokenLimChar(); needTerminator = true; break; } case TypeScript.TokenID.Enum: { this.currentToken = this.scanner.scan(); ast = this.parseEnumDecl(errorRecoverySet, modifiers); ast.minChar = minChar; ast.limChar = this.scanner.lastTokenLimChar(); if(this.parsingDeclareFile || this.ambientModule || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Ambient)) { (ast).modFlags |= TypeScript.ModuleFlags.Ambient; } if(this.parsingDeclareFile || this.ambientModule || TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported)) { (ast).modFlags |= TypeScript.ModuleFlags.Exported; } break; } case TypeScript.TokenID.Debugger: { mayNotBeExported(); if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("modifiers can not appear before debugger statement"); } minChar = this.scanner.startPos; this.currentToken = this.scanner.scan(); var debuggerStmt = new TypeScript.DebuggerStatement(); debuggerStmt.minChar = minChar; needTerminator = true; debuggerStmt.limChar = this.scanner.lastTokenLimChar(); ast = debuggerStmt; break; } default: { if(modifiers != TypeScript.Modifiers.None) { this.reportParseError("modifiers can not appear before an expression statement or label"); } minChar = this.scanner.startPos; var svPos = this.scanner.pos; temp = this.parseExpr(TypeScript.ErrorRecoverySet.Colon | TypeScript.ErrorRecoverySet.StmtStart | errorRecoverySet, TypeScript.OperatorPrecedence.None, true, TypeContext.NoTypes); if(this.scanner.pos == svPos) { this.currentToken = this.scanner.scan(); ast = temp; } else { if((this.currentToken.tokenId == TypeScript.TokenID.Colon) && (!this.scanner.lastTokenHadNewline()) && temp && (temp.nodeType == TypeScript.NodeType.Name)) { if(labelList == null) { labelList = new TypeScript.ASTList(); } labelList.append(new TypeScript.Label(temp)); this.currentToken = this.scanner.scan(); } else { ast = temp; needTerminator = true; } } } } if(ast) { break; } } if(needTerminator) { switch(this.currentToken.tokenId) { case TypeScript.TokenID.Semicolon: { this.currentToken = this.scanner.scan(); ast.flags |= TypeScript.ASTFlags.ExplicitSemicolon; break; } case TypeScript.TokenID.EndOfFile: { ast.limChar = this.scanner.pos; } case TypeScript.TokenID.CloseBrace: { ast.flags |= TypeScript.ASTFlags.AutomaticSemicolon; if(this.style_requireSemi) { this.reportParseStyleError("no automatic semicolon"); } break; } default: { if(!this.scanner.lastTokenHadNewline()) { this.reportParseError("Expected ';'"); } else { ast.flags |= TypeScript.ASTFlags.AutomaticSemicolon; if(this.style_requireSemi) { this.reportParseStyleError("no automatic semicolon"); } } break; } } } if(labelList) { ast = new TypeScript.LabeledStatement(labelList, ast); } ast.minChar = minChar; ast.limChar = TypeScript.max(ast.limChar, this.scanner.lastTokenLimChar()); if(preComments) { ast.preComments = preComments; } if(this.ambientModule && (!this.okAmbientModuleMember(ast))) { this.reportParseError("statement not permitted within ambient module"); } ast.flags |= TypeScript.ASTFlags.IsStatement; return ast; }; Parser.prototype.okAmbientModuleMember = function (ast) { var nt = ast.nodeType; return (nt == TypeScript.NodeType.ClassDeclaration) || (nt == TypeScript.NodeType.ImportDeclaration) || (nt == TypeScript.NodeType.InterfaceDeclaration) || (nt == TypeScript.NodeType.ModuleDeclaration) || (nt == TypeScript.NodeType.Empty) || (nt == TypeScript.NodeType.VarDecl) || ((nt == TypeScript.NodeType.Block) && !(ast).isStatementBlock) || ((nt == TypeScript.NodeType.FuncDecl) && ((ast).isMethod())); }; Parser.prototype.parseStatementList = function (errorRecoverySet, statements, sourceElms, noLeadingCase, allowedElements, parentModifiers) { var directivePrologue = sourceElms; statements.minChar = this.scanner.startPos; var limChar = this.scanner.pos; var innerStmts = (allowedElements & TypeScript.AllowedElements.ModuleDeclarations) == TypeScript.AllowedElements.None; var classNope = (allowedElements & TypeScript.AllowedElements.ClassDeclarations) == TypeScript.AllowedElements.None; errorRecoverySet |= TypeScript.ErrorRecoverySet.TypeScriptS | TypeScript.ErrorRecoverySet.RCurly; this.state = ParseState.StartStatementList; var oldStrictMode = this.strictMode; this.nestingLevel++; for(; ; ) { if((this.currentToken.tokenId == TypeScript.TokenID.CloseBrace) || (noLeadingCase && ((this.currentToken.tokenId == TypeScript.TokenID.Case) || (this.currentToken.tokenId == TypeScript.TokenID.Default))) || (innerStmts && (this.currentToken.tokenId == TypeScript.TokenID.Export)) || (classNope && (this.currentToken.tokenId == TypeScript.TokenID.Class)) || (this.currentToken.tokenId == TypeScript.TokenID.EndOfFile)) { this.state = ParseState.EndStmtList; statements.limChar = limChar; if(statements.members.length == 0) { statements.preComments = this.parseComments(); } else { statements.postComments = this.parseComments(); } this.strictMode = oldStrictMode; this.nestingLevel--; return; } var stmt = this.parseStatement(errorRecoverySet & (~(TypeScript.ErrorRecoverySet.Else | TypeScript.ErrorRecoverySet.RParen | TypeScript.ErrorRecoverySet.Catch | TypeScript.ErrorRecoverySet.Colon)), allowedElements, parentModifiers); if(stmt) { stmt.postComments = this.combineComments(stmt.postComments, this.parseCommentsForLine(this.scanner.prevLine)); statements.append(stmt); limChar = stmt.limChar; if(directivePrologue) { if(stmt.nodeType == TypeScript.NodeType.QString) { var qstring = stmt; if(qstring.text == "\"use strict\"") { statements.flags |= TypeScript.ASTFlags.StrictMode; this.strictMode = true; } else { directivePrologue = false; } } else { directivePrologue = false; } } } } }; Parser.prototype.quickParse = function (sourceText, filename, unitIndex) { var svGenTarget = TypeScript.moduleGenTarget; try { TypeScript.moduleGenTarget = TypeScript.ModuleGenTarget.Local; var script = this.parse(sourceText, filename, unitIndex, TypeScript.AllowedElements.QuickParse); return new QuickParseResult(script, this.scanner.lexState); }finally { TypeScript.moduleGenTarget = svGenTarget; } }; Parser.prototype.parse = function (sourceText, filename, unitIndex, allowedElements) { if (typeof allowedElements === "undefined") { allowedElements = TypeScript.AllowedElements.Global; } var _this = this; this.ambientModule = false; this.topLevel = true; this.hasTopLevelImportOrExport = false; this.requiresExtendsBlock = false; this.fname = filename; this.currentUnitIndex = unitIndex; this.amdDependencies = []; this.scanner.resetComments(); this.scanner.setErrorHandler(function (message) { return _this.reportParseError(message); }); this.scanner.setSourceText(sourceText, TypeScript.LexMode.File); var leftCurlyCount = this.scanner.leftCurlyCount; var rightCurlyCount = this.scanner.rightCurlyCount; var minChar = this.scanner.pos; this.currentToken = this.scanner.scan(); this.pushDeclLists(); var bod = new TypeScript.ASTList(); bod.minChar = minChar; this.state = ParseState.StartScript; this.parsingDeclareFile = TypeScript.isDSTRFile(filename) || TypeScript.isDTSFile(filename); while(true) { this.parseStatementList(TypeScript.ErrorRecoverySet.EOF | TypeScript.ErrorRecoverySet.Func, bod, true, false, allowedElements, TypeScript.Modifiers.None); if(this.currentToken.tokenId === TypeScript.TokenID.EndOfFile) { break; } var badToken = TypeScript.tokenTable[this.currentToken.tokenId]; this.reportParseError("Unexpected statement block terminator '" + badToken.text + "'"); this.currentToken = this.scanner.scan(); } this.state = ParseState.EndScript; bod.limChar = this.scanner.pos; var topLevelMod = null; if(TypeScript.moduleGenTarget != TypeScript.ModuleGenTarget.Local && this.hasTopLevelImportOrExport) { var correctedFileName = TypeScript.switchToForwardSlashes(filename); var id = new TypeScript.Identifier(correctedFileName); topLevelMod = new TypeScript.ModuleDeclaration(id, bod, this.topVarList(), this.topScopeList(), null); topLevelMod.modFlags |= TypeScript.ModuleFlags.IsDynamic; topLevelMod.modFlags |= TypeScript.ModuleFlags.IsWholeFile; topLevelMod.modFlags |= TypeScript.ModuleFlags.Exported; if(this.parsingDeclareFile) { topLevelMod.modFlags |= TypeScript.ModuleFlags.Ambient; } topLevelMod.minChar = minChar; topLevelMod.limChar = this.scanner.pos; topLevelMod.prettyName = TypeScript.getPrettyName(correctedFileName); topLevelMod.containsUnicodeChar = this.scanner.seenUnicodeChar; topLevelMod.containsUnicodeCharInComment = this.scanner.seenUnicodeCharInComment; topLevelMod.amdDependencies = this.amdDependencies; bod = new TypeScript.ASTList(); bod.minChar = topLevelMod.minChar; bod.limChar = topLevelMod.limChar; bod.append(topLevelMod); } var script = new TypeScript.Script(this.topVarList(), this.topScopeList()); script.bod = bod; this.popDeclLists(); script.minChar = minChar; script.limChar = this.scanner.pos; script.locationInfo = new TypeScript.LocationInfo(filename, this.scanner.lineMap, unitIndex); script.leftCurlyCount = this.scanner.leftCurlyCount - leftCurlyCount; script.rightCurlyCount = this.scanner.rightCurlyCount - rightCurlyCount; script.isDeclareFile = this.parsingDeclareFile; script.topLevelMod = topLevelMod; script.containsUnicodeChar = this.scanner.seenUnicodeChar; script.containsUnicodeCharInComment = this.scanner.seenUnicodeCharInComment; script.requiresExtendsBlock = this.requiresExtendsBlock; return script; }; return Parser; })(); TypeScript.Parser = Parser; function quickParse(logger, scopeStartAST, sourceText, minChar, limChar, errorCapture) { var fragment = sourceText.getText(minChar, limChar); logger.log("Quick parse range (" + minChar + "," + limChar + "): \"" + TypeScript.stringToLiteral(fragment, 100) + "\""); var quickParser = new Parser(); quickParser.setErrorRecovery(null); quickParser.errorCallback = errorCapture; var quickClassDecl = new TypeScript.ClassDeclaration(null, null, null, null); quickParser.currentClassDecl = quickClassDecl; var result = quickParser.quickParse(new TypeScript.StringSourceText(fragment), "", 0); return result; } TypeScript.quickParse = quickParse; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var PrintContext = (function () { function PrintContext(outfile, parser) { this.outfile = outfile; this.parser = parser; this.builder = ""; this.indent1 = " "; this.indentStrings = []; this.indentAmt = 0; } PrintContext.prototype.increaseIndent = function () { this.indentAmt++; }; PrintContext.prototype.decreaseIndent = function () { this.indentAmt--; }; PrintContext.prototype.startLine = function () { if(this.builder.length > 0) { TypeScript.CompilerDiagnostics.Alert(this.builder); } var indentString = this.indentStrings[this.indentAmt]; if(indentString === undefined) { indentString = ""; for(var i = 0; i < this.indentAmt; i++) { indentString += this.indent1; } this.indentStrings[this.indentAmt] = indentString; } this.builder += indentString; }; PrintContext.prototype.write = function (s) { this.builder += s; }; PrintContext.prototype.writeLine = function (s) { this.builder += s; this.outfile.WriteLine(this.builder); this.builder = ""; }; return PrintContext; })(); TypeScript.PrintContext = PrintContext; function prePrintAST(ast, parent, walker) { var pc = walker.state; ast.print(pc); pc.increaseIndent(); return ast; } TypeScript.prePrintAST = prePrintAST; function postPrintAST(ast, parent, walker) { var pc = walker.state; pc.decreaseIndent(); return ast; } TypeScript.postPrintAST = postPrintAST; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { TypeScript.LexEOF = (-1); TypeScript.LexCodeNWL = 10; TypeScript.LexCodeRET = 13; TypeScript.LexCodeLS = 8232; TypeScript.LexCodePS = 8233; TypeScript.LexCodeTAB = 9; TypeScript.LexCodeVTAB = 11; TypeScript.LexCode_e = 'e'.charCodeAt(0); TypeScript.LexCode_E = 'E'.charCodeAt(0); TypeScript.LexCode_x = 'x'.charCodeAt(0); TypeScript.LexCode_X = 'X'.charCodeAt(0); TypeScript.LexCode_a = 'a'.charCodeAt(0); TypeScript.LexCode_A = 'A'.charCodeAt(0); TypeScript.LexCode_f = 'f'.charCodeAt(0); TypeScript.LexCode_F = 'F'.charCodeAt(0); TypeScript.LexCode_g = 'g'.charCodeAt(0); TypeScript.LexCode_m = 'm'.charCodeAt(0); TypeScript.LexCode_i = 'i'.charCodeAt(0); TypeScript.LexCode_u = 'u'.charCodeAt(0); TypeScript.LexCode_0 = '0'.charCodeAt(0); TypeScript.LexCode_9 = '9'.charCodeAt(0); TypeScript.LexCode_8 = '8'.charCodeAt(0); TypeScript.LexCode_7 = '7'.charCodeAt(0); TypeScript.LexCodeBSL = '\\'.charCodeAt(0); TypeScript.LexCodeSHP = '#'.charCodeAt(0); TypeScript.LexCodeBNG = '!'.charCodeAt(0); TypeScript.LexCodeQUO = '"'.charCodeAt(0); TypeScript.LexCodeAPO = '\''.charCodeAt(0); TypeScript.LexCodePCT = '%'.charCodeAt(0); TypeScript.LexCodeAMP = '&'.charCodeAt(0); TypeScript.LexCodeLPR = '('.charCodeAt(0); TypeScript.LexCodeRPR = ')'.charCodeAt(0); TypeScript.LexCodePLS = '+'.charCodeAt(0); TypeScript.LexCodeMIN = '-'.charCodeAt(0); TypeScript.LexCodeMUL = '*'.charCodeAt(0); TypeScript.LexCodeSLH = '/'.charCodeAt(0); TypeScript.LexCodeXOR = '^'.charCodeAt(0); TypeScript.LexCodeCMA = ','.charCodeAt(0); TypeScript.LexCodeDOT = '.'.charCodeAt(0); TypeScript.LexCodeLT = '<'.charCodeAt(0); TypeScript.LexCodeEQ = '='.charCodeAt(0); TypeScript.LexCodeGT = '>'.charCodeAt(0); TypeScript.LexCodeQUE = '?'.charCodeAt(0); TypeScript.LexCodeLBR = '['.charCodeAt(0); TypeScript.LexCodeRBR = ']'.charCodeAt(0); TypeScript.LexCodeUSC = '_'.charCodeAt(0); TypeScript.LexCodeLC = '{'.charCodeAt(0); TypeScript.LexCodeRC = '}'.charCodeAt(0); TypeScript.LexCodeBAR = '|'.charCodeAt(0); TypeScript.LexCodeTIL = '~'.charCodeAt(0); TypeScript.LexCodeCOL = ':'.charCodeAt(0); TypeScript.LexCodeSMC = ';'.charCodeAt(0); TypeScript.LexCodeUnderscore = '_'.charCodeAt(0); TypeScript.LexCodeDollar = '$'.charCodeAt(0); TypeScript.LexCodeSpace = 32; TypeScript.LexCodeAtSign = '@'.charCodeAt(0); TypeScript.LexCodeASCIIChars = 128; TypeScript.LexKeywordTable = undefined; var autoToken = new Array(TypeScript.LexCodeASCIIChars); var lexIdStartTable = new Array(TypeScript.LexCodeASCIIChars); var unicodeES3IdStart = [ 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 13312, 19893, 19893, 19968, 19968, 40869, 40869, 40960, 42124, 44032, 44032, 55203, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500 ]; var unicodeES3IdCont = [ 768, 846, 864, 866, 1155, 1158, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1611, 1621, 1632, 1641, 1648, 1648, 1750, 1756, 1759, 1764, 1767, 1768, 1770, 1773, 1776, 1785, 1809, 1809, 1840, 1866, 1958, 1968, 2305, 2307, 2364, 2364, 2366, 2381, 2385, 2388, 2402, 2403, 2406, 2415, 2433, 2435, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2530, 2531, 2534, 2543, 2562, 2562, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2662, 2673, 2689, 2691, 2748, 2748, 2750, 2757, 2759, 2761, 2763, 2765, 2790, 2799, 2817, 2819, 2876, 2876, 2878, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2918, 2927, 2946, 2947, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3174, 3183, 3202, 3203, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3302, 3311, 3330, 3331, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3430, 3439, 3458, 3459, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3633, 3633, 3636, 3642, 3655, 3662, 3664, 3673, 3761, 3761, 3764, 3769, 3771, 3772, 3784, 3789, 3792, 3801, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3903, 3953, 3972, 3974, 3975, 3984, 3991, 3993, 4028, 4038, 4038, 4140, 4146, 4150, 4153, 4160, 4169, 4182, 4185, 4969, 4977, 6068, 6099, 6112, 6121, 6160, 6169, 6313, 6313, 8255, 8256, 8400, 8412, 8417, 8417, 12330, 12335, 12441, 12442, 12539, 12539, 64286, 64286, 65056, 65059, 65075, 65076, 65101, 65103, 65296, 65305, 65343, 65343, 65381, 65381 ]; var unicodeES5IdStart = [ 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 13312, 19893, 19893, 19968, 19968, 40908, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 44032, 55203, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500 ]; var unicodeES5IdCont = [ 768, 879, 1155, 1159, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1552, 1562, 1611, 1641, 1648, 1648, 1750, 1756, 1759, 1764, 1767, 1768, 1770, 1773, 1776, 1785, 1809, 1809, 1840, 1866, 1958, 1968, 1984, 1993, 2027, 2035, 2070, 2073, 2075, 2083, 2085, 2087, 2089, 2093, 2137, 2139, 2276, 2302, 2304, 2307, 2362, 2364, 2366, 2383, 2385, 2391, 2402, 2403, 2406, 2415, 2433, 2435, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2530, 2531, 2534, 2543, 2561, 2563, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2662, 2673, 2677, 2677, 2689, 2691, 2748, 2748, 2750, 2757, 2759, 2761, 2763, 2765, 2786, 2787, 2790, 2799, 2817, 2819, 2876, 2876, 2878, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2914, 2915, 2918, 2927, 2946, 2946, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3046, 3055, 3073, 3075, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3170, 3171, 3174, 3183, 3202, 3203, 3260, 3260, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3298, 3299, 3302, 3311, 3330, 3331, 3390, 3396, 3398, 3400, 3402, 3405, 3415, 3415, 3426, 3427, 3430, 3439, 3458, 3459, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3633, 3633, 3636, 3642, 3655, 3662, 3664, 3673, 3761, 3761, 3764, 3769, 3771, 3772, 3784, 3789, 3792, 3801, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3903, 3953, 3972, 3974, 3975, 3981, 3991, 3993, 4028, 4038, 4038, 4139, 4158, 4160, 4169, 4182, 4185, 4190, 4192, 4194, 4196, 4199, 4205, 4209, 4212, 4226, 4237, 4239, 4253, 4957, 4959, 5906, 5908, 5938, 5940, 5970, 5971, 6002, 6003, 6068, 6099, 6109, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6313, 6313, 6432, 6443, 6448, 6459, 6470, 6479, 6576, 6592, 6600, 6601, 6608, 6617, 6679, 6683, 6741, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6912, 6916, 6964, 6980, 6992, 7001, 7019, 7027, 7040, 7042, 7073, 7085, 7088, 7097, 7142, 7155, 7204, 7223, 7232, 7241, 7248, 7257, 7376, 7378, 7380, 7400, 7405, 7405, 7410, 7412, 7616, 7654, 7676, 7679, 8204, 8205, 8255, 8256, 8276, 8276, 8400, 8412, 8417, 8417, 8421, 8432, 11503, 11505, 11647, 11647, 11744, 11775, 12330, 12335, 12441, 12442, 42528, 42537, 42607, 42607, 42612, 42621, 42655, 42655, 42736, 42737, 43010, 43010, 43014, 43014, 43019, 43019, 43043, 43047, 43136, 43137, 43188, 43204, 43216, 43225, 43232, 43249, 43264, 43273, 43302, 43309, 43335, 43347, 43392, 43395, 43443, 43456, 43472, 43481, 43561, 43574, 43587, 43587, 43596, 43597, 43600, 43609, 43643, 43643, 43696, 43696, 43698, 43700, 43703, 43704, 43710, 43711, 43713, 43713, 43755, 43759, 43765, 43766, 44003, 44010, 44012, 44013, 44016, 44025, 64286, 64286, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65296, 65305, 65343, 65343 ]; function LexLookUpUnicodeMap(code, map) { var lo = 0; var hi = map.length; var mid; while(lo + 1 < hi) { mid = lo + (hi - lo) / 2; mid -= mid % 2; if(map[mid] <= code && code <= map[mid + 1]) { return true; } if(code < map[mid]) { hi = mid; } else { lo = mid + 2; } } return false; } TypeScript.LexLookUpUnicodeMap = LexLookUpUnicodeMap; function LexIsUnicodeDigit(code) { if(TypeScript.codeGenTarget == TypeScript.CodeGenTarget.ES3) { return LexLookUpUnicodeMap(code, unicodeES3IdCont); } else { return LexLookUpUnicodeMap(code, unicodeES5IdCont); } } TypeScript.LexIsUnicodeDigit = LexIsUnicodeDigit; function LexIsUnicodeIdStart(code) { if(TypeScript.codeGenTarget == TypeScript.CodeGenTarget.ES3) { return LexLookUpUnicodeMap(code, unicodeES3IdStart); } else { return LexLookUpUnicodeMap(code, unicodeES5IdStart); } } TypeScript.LexIsUnicodeIdStart = LexIsUnicodeIdStart; function LexInitialize() { TypeScript.initializeStaticTokens(); autoToken[TypeScript.LexCodeLPR] = TypeScript.staticTokens[TypeScript.TokenID.OpenParen]; autoToken[TypeScript.LexCodeRPR] = TypeScript.staticTokens[TypeScript.TokenID.CloseParen]; autoToken[TypeScript.LexCodeCMA] = TypeScript.staticTokens[TypeScript.TokenID.Comma]; autoToken[TypeScript.LexCodeSMC] = TypeScript.staticTokens[TypeScript.TokenID.Semicolon]; autoToken[TypeScript.LexCodeLBR] = TypeScript.staticTokens[TypeScript.TokenID.OpenBracket]; autoToken[TypeScript.LexCodeRBR] = TypeScript.staticTokens[TypeScript.TokenID.CloseBracket]; autoToken[TypeScript.LexCodeTIL] = TypeScript.staticTokens[TypeScript.TokenID.Tilde]; autoToken[TypeScript.LexCodeQUE] = TypeScript.staticTokens[TypeScript.TokenID.Question]; autoToken[TypeScript.LexCodeLC] = TypeScript.staticTokens[TypeScript.TokenID.OpenBrace]; autoToken[TypeScript.LexCodeRC] = TypeScript.staticTokens[TypeScript.TokenID.CloseBrace]; autoToken[TypeScript.LexCodeCOL] = TypeScript.staticTokens[TypeScript.TokenID.Colon]; TypeScript.LexKeywordTable = new TypeScript.StringHashTable(); for(var i in (TypeScript.TokenID)._map) { if((i) <= TypeScript.TokenID.LimKeyword) { TypeScript.LexKeywordTable.add((TypeScript.TokenID)._map[i].toLowerCase(), i); } } for(var j = 0; j < TypeScript.LexCodeASCIIChars; j++) { if(LexIsIdentifierStartChar(j)) { lexIdStartTable[j] = true; } else { lexIdStartTable[j] = false; } } } TypeScript.LexInitialize = LexInitialize; function LexAdjustIndent(code, indentAmt) { if((code == TypeScript.LexCodeLBR) || (code == TypeScript.LexCodeLC) || (code == TypeScript.LexCodeLPR)) { return indentAmt + 1; } else { if((code == TypeScript.LexCodeRBR) || (code == TypeScript.LexCodeRC) || (code == TypeScript.LexCodeRPR)) { return indentAmt - 1; } else { return indentAmt; } } } TypeScript.LexAdjustIndent = LexAdjustIndent; function LexIsIdentifierStartChar(code) { return (((code >= 97) && (code <= 122)) || ((code >= 65) && (code <= 90)) || (code == TypeScript.LexCodeDollar) || (code == TypeScript.LexCodeUnderscore)); } TypeScript.LexIsIdentifierStartChar = LexIsIdentifierStartChar; function LexIsDigit(code) { return ((code >= 48) && (code <= 57)); } TypeScript.LexIsDigit = LexIsDigit; function LexIsIdentifierChar(code) { return lexIdStartTable[code] || LexIsDigit(code); } TypeScript.LexIsIdentifierChar = LexIsIdentifierChar; function LexMatchingOpen(code) { if(code == TypeScript.LexCodeRBR) { return TypeScript.LexCodeLBR; } else { if(code == TypeScript.LexCodeRC) { return TypeScript.LexCodeLC; } else { if(code == TypeScript.LexCodeRPR) { return TypeScript.LexCodeLPR; } else { return 0; } } } } TypeScript.LexMatchingOpen = LexMatchingOpen; (function (NumberScanState) { NumberScanState._map = []; NumberScanState._map[0] = "Start"; NumberScanState.Start = 0; NumberScanState._map[1] = "InFraction"; NumberScanState.InFraction = 1; NumberScanState._map[2] = "InEmptyFraction"; NumberScanState.InEmptyFraction = 2; NumberScanState._map[3] = "InExponent"; NumberScanState.InExponent = 3; })(TypeScript.NumberScanState || (TypeScript.NumberScanState = {})); var NumberScanState = TypeScript.NumberScanState; (function (LexState) { LexState._map = []; LexState._map[0] = "Start"; LexState.Start = 0; LexState._map[1] = "InMultilineComment"; LexState.InMultilineComment = 1; LexState._map[2] = "InMultilineSingleQuoteString"; LexState.InMultilineSingleQuoteString = 2; LexState._map[3] = "InMultilineDoubleQuoteString"; LexState.InMultilineDoubleQuoteString = 3; })(TypeScript.LexState || (TypeScript.LexState = {})); var LexState = TypeScript.LexState; (function (LexMode) { LexMode._map = []; LexMode._map[0] = "Line"; LexMode.Line = 0; LexMode._map[1] = "File"; LexMode.File = 1; })(TypeScript.LexMode || (TypeScript.LexMode = {})); var LexMode = TypeScript.LexMode; (function (CommentStyle) { CommentStyle._map = []; CommentStyle._map[0] = "Line"; CommentStyle.Line = 0; CommentStyle._map[1] = "Block"; CommentStyle.Block = 1; })(TypeScript.CommentStyle || (TypeScript.CommentStyle = {})); var CommentStyle = TypeScript.CommentStyle; var StringSourceText = (function () { function StringSourceText(text) { this.text = text; } StringSourceText.prototype.getText = function (start, end) { return this.text.substring(start, end); }; StringSourceText.prototype.getLength = function () { return this.text.length; }; return StringSourceText; })(); TypeScript.StringSourceText = StringSourceText; var SourceTextSegment = (function () { function SourceTextSegment(segmentStart, segmentEnd, segment) { this.segmentStart = segmentStart; this.segmentEnd = segmentEnd; this.segment = segment; } SourceTextSegment.prototype.charCodeAt = function (index) { return this.segment.charCodeAt(index - this.segmentStart); }; SourceTextSegment.prototype.substring = function (start, end) { return this.segment.substring(start - this.segmentStart, end - this.segmentStart); }; return SourceTextSegment; })(); TypeScript.SourceTextSegment = SourceTextSegment; var AggerateSourceTextSegment = (function () { function AggerateSourceTextSegment(seg1, seg2) { this.seg1 = seg1; this.seg2 = seg2; } AggerateSourceTextSegment.prototype.charCodeAt = function (index) { if(this.seg1.segmentStart <= index && index < this.seg1.segmentEnd) { return this.seg1.segment.charCodeAt(index - this.seg1.segmentStart); } return this.seg2.segment.charCodeAt(index - this.seg2.segmentStart); }; AggerateSourceTextSegment.prototype.substring = function (start, end) { if(this.seg1.segmentStart <= start && end <= this.seg1.segmentEnd) { return this.seg1.segment.substring(start - this.seg1.segmentStart, end - this.seg1.segmentStart); } return this.seg2.segment.substring(start - this.seg2.segmentStart) + this.seg1.segment.substring(0, end - this.seg1.segmentStart); }; return AggerateSourceTextSegment; })(); TypeScript.AggerateSourceTextSegment = AggerateSourceTextSegment; var ScannerTextStream = (function () { function ScannerTextStream(sourceText) { this.sourceText = sourceText; this.agg = new AggerateSourceTextSegment(ScannerTextStream.emptySegment, ScannerTextStream.emptySegment); this.len = this.sourceText.getLength(); } ScannerTextStream.emptySegment = new SourceTextSegment(0, 0, ""); ScannerTextStream.prototype.max = function (a, b) { return a >= b ? a : b; }; ScannerTextStream.prototype.min = function (a, b) { return a <= b ? a : b; }; ScannerTextStream.prototype.fetchSegment = function (start, end) { if(this.agg.seg1.segmentStart <= start && end <= this.agg.seg1.segmentEnd) { return this.agg.seg1; } if(this.agg.seg2.segmentStart <= start && end <= this.agg.seg1.segmentEnd) { return this.agg; } var prev = this.agg.seg1; var s = prev.segmentEnd; var e = TypeScript.max(s + 512, end); e = TypeScript.min(e, this.len); var src = this.sourceText.getText(s, e); var newSeg = new SourceTextSegment(s, e, src); this.agg.seg2 = prev; this.agg.seg1 = newSeg; return this.agg; }; ScannerTextStream.prototype.charCodeAt = function (index) { return this.fetchSegment(index, index + 1).charCodeAt(index); }; ScannerTextStream.prototype.substring = function (start, end) { return this.fetchSegment(start, end).substring(start, end); }; return ScannerTextStream; })(); TypeScript.ScannerTextStream = ScannerTextStream; var SavedTokens = (function () { function SavedTokens() { this.prevToken = null; this.curSavedToken = null; this.prevSavedToken = null; this.prevToken = null; this.currentToken = 0; this.tokens = new Array(); this.seenUnicodeChar = false; this.seenUnicodeCharInComment = false; this.prevLine = 1; this.line = 1; this.col = 0; this.lexState = LexState.Start; this.commentStack = new Array(); this.lineMap = []; } SavedTokens.prototype.previousToken = function () { return this.prevToken; }; SavedTokens.prototype.close = function () { this.currentToken = 0; }; SavedTokens.prototype.addToken = function (tok, scanner) { this.tokens[this.currentToken++] = new TypeScript.SavedToken(tok, scanner.startPos, scanner.pos); }; SavedTokens.prototype.scan = function () { this.startLine = this.line; this.startPos = this.col; if(this.currentTokenIndex == this.currentTokens.length) { if(this.line < this.lineMap.length) { this.line++; this.col = 0; this.currentTokenIndex = 0; this.currentTokens = this.tokensByLine[this.line]; } else { return TypeScript.staticTokens[TypeScript.TokenID.EndOfFile]; } } if(this.currentTokenIndex < this.currentTokens.length) { this.prevToken = this.curSavedToken.tok; this.prevSavedToken = this.curSavedToken; this.curSavedToken = this.currentTokens[this.currentTokenIndex++]; var curToken = this.curSavedToken.tok; this.pos = this.curSavedToken.limChar; this.col += (this.curSavedToken.limChar - this.curSavedToken.minChar); this.startPos = this.curSavedToken.minChar; this.prevLine = this.line; return curToken; } else { return TypeScript.staticTokens[TypeScript.TokenID.EndOfFile]; } }; SavedTokens.prototype.syncToTok = function (offset) { this.line = getLineNumberFromPosition(this.lineMap, offset); this.currentTokenIndex = 0; var tmpCol = offset - this.lineMap[this.line]; while((this.lexStateByLine[this.line] == LexState.InMultilineComment) && (this.line > 0)) { this.line--; tmpCol = 0; } var lenMin1 = this.lineMap.length - 1; this.currentTokens = this.tokensByLine[this.line]; while((this.currentTokens.length == 0) && (this.line < lenMin1)) { this.line++; this.currentTokens = this.tokensByLine[this.line]; tmpCol = 0; } if(this.line <= lenMin1) { while((this.currentTokenIndex < this.currentTokens.length) && (tmpCol > this.currentTokens[this.currentTokenIndex].limChar)) { this.currentTokenIndex++; } if(this.currentTokenIndex < this.currentTokens.length) { this.col = this.currentTokens[this.currentTokenIndex].minChar; return this.col + this.lineMap[this.line]; } } return -1; }; SavedTokens.prototype.lastTokenLimChar = function () { if(this.prevSavedToken !== null) { return this.prevSavedToken.limChar; } else { return 0; } }; SavedTokens.prototype.lastTokenHadNewline = function () { return this.prevLine != this.startLine; }; SavedTokens.prototype.pushComment = function (comment) { this.commentStack.push(comment); }; SavedTokens.prototype.getComments = function () { var stack = this.commentStack; this.commentStack = []; return stack; }; SavedTokens.prototype.getCommentsForLine = function (line) { var comments = null; while((this.commentStack.length > 0) && (this.commentStack[0].line == line)) { if(comments == null) { comments = [ this.commentStack.shift() ]; } else { comments = comments.concat([ this.commentStack.shift() ]); } } return comments; }; SavedTokens.prototype.resetComments = function () { this.commentStack = []; }; SavedTokens.prototype.setSourceText = function (newSrc, textMode) { }; SavedTokens.prototype.setErrorHandler = function (reportError) { }; SavedTokens.prototype.getLookAheadToken = function () { throw new Error("Invalid operation."); }; return SavedTokens; })(); TypeScript.SavedTokens = SavedTokens; var Scanner = (function () { function Scanner() { this.prevLine = 1; this.line = 1; this.col = 0; this.pos = 0; this.startPos = 0; this.len = 0; this.lineMap = []; this.ch = TypeScript.LexEOF; this.lexState = LexState.Start; this.mode = LexMode.File; this.scanComments = true; this.interveningWhitespace = false; this.interveningWhitespacePos = 0; this.leftCurlyCount = 0; this.rightCurlyCount = 0; this.commentStack = new Array(); this.saveScan = null; this.seenUnicodeChar = false; this.seenUnicodeCharInComment = false; this.prevTok = TypeScript.staticTokens[TypeScript.TokenID.EndOfFile]; this.startCol = this.col; this.startLine = this.line; this.lineMap[1] = 0; if(!TypeScript.LexKeywordTable) { LexInitialize(); } } Scanner.prototype.previousToken = function () { return this.prevTok; }; Scanner.prototype.setSourceText = function (newSrc, textMode) { this.mode = textMode; this.scanComments = (this.mode === LexMode.Line); this.pos = 0; this.interveningWhitespacePos = 0; this.startPos = 0; this.line = 1; this.col = 0; this.startCol = this.col; this.startLine = this.line; this.len = 0; this.src = newSrc.getText(0, newSrc.getLength()); this.len = this.src.length; this.lineMap = []; this.lineMap[1] = 0; this.commentStack = []; this.leftCurlyCount = 0; this.rightCurlyCount = 0; this.seenUnicodeChar = false; this.seenUnicodeCharInComment = false; }; Scanner.prototype.setErrorHandler = function (reportError) { this.reportError = reportError; }; Scanner.prototype.setSaveScan = function (savedTokens) { this.saveScan = savedTokens; }; Scanner.prototype.setText = function (newSrc, textMode) { this.setSourceText(new StringSourceText(newSrc), textMode); }; Scanner.prototype.setScanComments = function (value) { this.scanComments = value; }; Scanner.prototype.getLexState = function () { return this.lexState; }; Scanner.prototype.tokenStart = function () { this.startPos = this.pos; this.startLine = this.line; this.startCol = this.col; this.interveningWhitespace = false; }; Scanner.prototype.peekChar = function () { if(this.pos < this.len) { return this.src.charCodeAt(this.pos); } else { return TypeScript.LexEOF; } }; Scanner.prototype.peekCharAt = function (index) { if(index < this.len) { return this.src.charCodeAt(index); } else { return TypeScript.LexEOF; } }; Scanner.prototype.IsHexDigit = function (c) { return ((c >= TypeScript.LexCode_0) && (c <= TypeScript.LexCode_9)) || ((c >= TypeScript.LexCode_A) && (c <= TypeScript.LexCode_F)) || ((c >= TypeScript.LexCode_a) && (c <= TypeScript.LexCode_f)); }; Scanner.prototype.IsOctalDigit = function (c) { return ((c >= TypeScript.LexCode_0) && (c <= TypeScript.LexCode_7)) || ((c >= TypeScript.LexCode_a) && (c <= TypeScript.LexCode_f)); }; Scanner.prototype.scanHexDigits = function () { var atLeastOneDigit = false; for(; ; ) { if(this.IsHexDigit(this.ch)) { this.nextChar(); atLeastOneDigit = true; } else { if(atLeastOneDigit) { return new TypeScript.NumberLiteralToken(parseInt(this.src.substring(this.startPos, this.pos))); } else { return null; } } } }; Scanner.prototype.scanOctalDigits = function () { var atLeastOneDigit = false; for(; ; ) { if(this.IsOctalDigit(this.ch)) { this.nextChar(); atLeastOneDigit = true; } else { if(atLeastOneDigit) { return new TypeScript.NumberLiteralToken(parseInt(this.src.substring(this.startPos, this.pos))); } else { return null; } } } }; Scanner.prototype.scanDecimalNumber = function (state) { var atLeastOneDigit = false; var svPos = this.pos; var svCol = this.col; for(; ; ) { if(LexIsDigit(this.ch)) { atLeastOneDigit = true; if(this.ch != TypeScript.LexCode_0 && state == NumberScanState.InEmptyFraction) { state = NumberScanState.InFraction; } this.nextChar(); } else { if(this.ch == TypeScript.LexCodeDOT) { if(state == NumberScanState.Start) { this.nextChar(); state = NumberScanState.InEmptyFraction; } else { if(atLeastOneDigit) { return new TypeScript.NumberLiteralToken(parseFloat(this.src.substring(this.startPos, this.pos)), state == NumberScanState.InEmptyFraction); } else { this.pos = svPos; this.col = svCol; return null; } } } else { if((this.ch == TypeScript.LexCode_e) || (this.ch == TypeScript.LexCode_E)) { if(state == NumberScanState.Start) { if(atLeastOneDigit) { atLeastOneDigit = false; this.nextChar(); state = NumberScanState.InExponent; } else { this.pos = svPos; this.col = svCol; return null; } } else { if(state == NumberScanState.InFraction || state == NumberScanState.InEmptyFraction) { this.nextChar(); state = NumberScanState.InExponent; atLeastOneDigit = false; } else { if(atLeastOneDigit) { return new TypeScript.NumberLiteralToken(parseFloat(this.src.substring(this.startPos, this.pos))); } else { this.pos = svPos; this.col = svCol; return null; } } } } else { if((this.ch == TypeScript.LexCodePLS) || (this.ch == TypeScript.LexCodeMIN)) { if(state == NumberScanState.InExponent) { if(!atLeastOneDigit) { this.nextChar(); } else { this.pos = svPos; this.col = svCol; return null; } } else { if(state == NumberScanState.InEmptyFraction || state == NumberScanState.InFraction) { return new TypeScript.NumberLiteralToken(parseFloat(this.src.substring(this.startPos, this.pos)), state == NumberScanState.InEmptyFraction); } else { if(!atLeastOneDigit) { this.pos = svPos; this.col = svCol; return null; } else { return new TypeScript.NumberLiteralToken(parseFloat(this.src.substring(this.startPos, this.pos))); } } } } else { if(!atLeastOneDigit) { this.pos = svPos; this.col = svCol; return null; } else { return new TypeScript.NumberLiteralToken(parseFloat(this.src.substring(this.startPos, this.pos)), state == NumberScanState.InEmptyFraction); } } } } } } }; Scanner.prototype.scanNumber = function () { if(this.peekChar() == TypeScript.LexCode_0) { switch(this.peekCharAt(this.pos + 1)) { case TypeScript.LexCode_x: case TypeScript.LexCode_X: { this.advanceChar(2); return this.scanHexDigits(); } case TypeScript.LexCode_8: case TypeScript.LexCode_9: case TypeScript.LexCodeDOT: { return this.scanDecimalNumber(NumberScanState.Start); } default: { return this.scanOctalDigits(); } } } else { return this.scanDecimalNumber(NumberScanState.Start); } }; Scanner.prototype.scanFraction = function () { return this.scanDecimalNumber(NumberScanState.InFraction); }; Scanner.prototype.newLine = function () { this.col = 0; if(this.mode == LexMode.File) { this.line++; this.lineMap[this.line] = this.pos + 1; } }; Scanner.prototype.finishMultilineComment = function () { var ch2; this.lexState = LexState.InMultilineComment; while(this.pos < this.len) { if(this.ch == TypeScript.LexCodeMUL) { ch2 = this.peekCharAt(this.pos + 1); if(ch2 == TypeScript.LexCodeSLH) { this.advanceChar(2); if(this.mode == LexMode.File) { this.tokenStart(); } this.lexState = LexState.Start; return true; } } else { if(this.ch == TypeScript.LexCodeNWL) { this.newLine(); if(this.mode == LexMode.Line) { this.nextChar(); return false; } } else { if(this.ch >= TypeScript.LexCodeASCIIChars) { this.seenUnicodeCharInComment = true; } } } this.nextChar(); } return false; }; Scanner.prototype.pushComment = function (comment) { this.commentStack.push(comment); }; Scanner.prototype.getComments = function () { var stack = this.commentStack; this.commentStack = []; return stack; }; Scanner.prototype.getCommentsForLine = function (line) { var comments = null; while((this.commentStack.length > 0) && (this.commentStack[0].line == line)) { if(comments == null) { comments = [ this.commentStack.shift() ]; } else { comments = comments.concat([ this.commentStack.shift() ]); } } return comments; }; Scanner.prototype.resetComments = function () { this.commentStack = []; }; Scanner.prototype.endsLine = function (c) { return (c == TypeScript.LexCodeNWL) || (c == TypeScript.LexCodeRET) || (c == TypeScript.LexCodeLS) || (c == TypeScript.LexCodePS); }; Scanner.prototype.finishSinglelineComment = function () { while(this.pos < this.len) { if(this.endsLine(this.ch)) { break; } if(this.ch >= TypeScript.LexCodeASCIIChars) { this.seenUnicodeCharInComment = true; } this.nextChar(); } if(this.mode == LexMode.File) { this.tokenStart(); } }; Scanner.prototype.tokenText = function () { return this.src.substring(this.startPos, this.pos); }; Scanner.prototype.findClosingSLH = function () { var index = this.pos; var ch2 = this.src.charCodeAt(index); var prevCh = 0; var liveEsc = false; while(!this.endsLine(ch2) && (index < this.len)) { if((ch2 == TypeScript.LexCodeSLH) && (!liveEsc)) { return index; } prevCh = ch2; index++; if(liveEsc) { liveEsc = false; } else { liveEsc = (prevCh == TypeScript.LexCodeBSL); } ch2 = this.src.charCodeAt(index); } return -1; }; Scanner.prototype.speculateRegex = function () { if(TypeScript.noRegexTable[this.prevTok.tokenId] != undefined) { return null; } var svPos = this.pos; var svCol = this.col; var index = this.findClosingSLH(); if(index > 0) { var pattern = this.src.substring(svPos, index); var flags = ""; this.pos = index + 1; this.ch = this.peekChar(); var flagsStart = this.pos; while((this.ch == TypeScript.LexCode_i) || (this.ch == TypeScript.LexCode_g) || (this.ch == TypeScript.LexCode_m)) { this.nextChar(); } if((this.pos - flagsStart) > 3) { return null; } else { flags = this.src.substring(flagsStart, this.pos); } var regex = undefined; try { regex = new RegExp(pattern, flags); } catch (regexException) { } if(regex) { this.col = svCol + (this.pos - this.startPos); return new TypeScript.RegularExpressionLiteralToken(regex); } } this.pos = svPos; this.col = svCol; return null; }; Scanner.prototype.lastTokenHadNewline = function () { return this.prevLine != this.startLine; }; Scanner.prototype.lastTokenLimChar = function () { return this.interveningWhitespace ? this.interveningWhitespacePos : this.startPos; }; Scanner.prototype.advanceChar = function (amt) { this.pos += amt; this.col += amt; this.ch = this.peekChar(); }; Scanner.prototype.nextChar = function () { this.pos++; this.col++; this.ch = this.peekChar(); }; Scanner.prototype.getLookAheadToken = function () { var prevLine = this.prevLine; var line = this.line; var col = this.col; var pos = this.pos; var startPos = this.startPos; var startCol = this.startCol; var startLine = this.startLine; var ch = this.ch; var prevTok = this.prevTok; var lexState = this.lexState; var interveningWhitespace = this.interveningWhitespace; var interveningWhitespacePos = this.interveningWhitespacePos; var leftCurlyCount = this.leftCurlyCount; var rightCurlyCount = this.rightCurlyCount; var seenUnicodeChar = this.seenUnicodeChar; var seenUnicodeCharInComment = this.seenUnicodeCharInComment; var commentStackLength = this.commentStack.length; var lookAheadToken = this.scan(); this.prevLine = prevLine; this.line = line; this.col = col; this.pos = pos; this.startPos = startPos; this.startCol = startCol; this.startLine = startLine; this.ch = ch; this.prevTok = prevTok; this.lexState = lexState; this.interveningWhitespace = interveningWhitespace; this.interveningWhitespacePos = interveningWhitespacePos; this.leftCurlyCount = leftCurlyCount; this.rightCurlyCount = rightCurlyCount; this.seenUnicodeChar = seenUnicodeChar; this.seenUnicodeCharInComment = seenUnicodeCharInComment; this.commentStack.length = commentStackLength; return lookAheadToken; }; Scanner.prototype.scanInLine = function () { if((this.lexState == LexState.InMultilineComment) && (this.scanComments)) { this.ch = this.peekChar(); var commentLine = this.line; this.finishMultilineComment(); if(this.startPos < this.pos) { var commentText = this.src.substring(this.startPos, this.pos); this.tokenStart(); return new TypeScript.CommentToken(TypeScript.TokenID.Comment, commentText, true, this.startPos, commentLine, true); } else { return TypeScript.staticTokens[TypeScript.TokenID.EndOfFile]; } } else { if(this.lexState == LexState.InMultilineSingleQuoteString && this.pos < this.len) { this.ch = TypeScript.LexCodeAPO; this.lexState = LexState.Start; return this.scanStringConstant(); } else { if(this.lexState == LexState.InMultilineDoubleQuoteString && this.pos < this.len) { this.ch = TypeScript.LexCodeQUO; this.lexState = LexState.Start; return this.scanStringConstant(); } } } this.prevLine = this.line; var prevTok = this.innerScan(); if(prevTok.tokenId != TypeScript.TokenID.Whitespace) { this.prevTok = prevTok; } return prevTok; }; Scanner.prototype.scan = function () { this.prevLine = this.line; this.prevTok = this.innerScan(); if(this.saveScan) { this.saveScan.addToken(this.prevTok, this); } return this.prevTok; }; Scanner.prototype.isValidUnicodeIdentifierChar = function () { var valid = LexIsUnicodeIdStart(this.ch) || LexIsUnicodeDigit(this.ch); this.seenUnicodeChar = this.seenUnicodeChar || valid; return valid; }; Scanner.prototype.scanStringConstant = function () { var endCode = this.ch; this.nextChar(); scanStringConstantLoop: for(; ; ) { switch(this.ch) { case TypeScript.LexEOF: { this.reportScannerError("Unterminated string constant"); break scanStringConstantLoop; } case TypeScript.LexCodeLS: case TypeScript.LexCodePS: { this.seenUnicodeChar = true; } case TypeScript.LexCodeRET: case TypeScript.LexCodeNWL: { this.reportScannerError("Unterminated string constant"); break scanStringConstantLoop; } case TypeScript.LexCodeAPO: case TypeScript.LexCodeQUO: { if(this.ch == endCode) { this.nextChar(); break scanStringConstantLoop; } break; } case TypeScript.LexCodeBSL: { this.nextChar(); switch(this.ch) { case TypeScript.LexCodeAPO: case TypeScript.LexCodeQUO: case TypeScript.LexCodeBSL: { this.nextChar(); continue scanStringConstantLoop; } case TypeScript.LexCodeLS: case TypeScript.LexCodePS: { this.seenUnicodeChar = true; } case TypeScript.LexCodeRET: case TypeScript.LexCodeNWL: { if(this.ch == TypeScript.LexCodeRET && this.peekCharAt(this.pos + 1) == TypeScript.LexCodeNWL) { this.nextChar(); } this.nextChar(); this.newLine(); if(this.mode == LexMode.Line) { this.lexState = endCode == TypeScript.LexCodeAPO ? LexState.InMultilineSingleQuoteString : LexState.InMultilineDoubleQuoteString; break scanStringConstantLoop; } break; } case TypeScript.LexCode_x: case TypeScript.LexCode_u: { var expectedHexDigits = this.ch == TypeScript.LexCode_x ? 2 : 4; this.nextChar(); for(var i = 0; i < expectedHexDigits; i++) { if(this.IsHexDigit(this.ch)) { this.nextChar(); } else { this.reportScannerError("Invalid Unicode escape sequence"); break; } } continue scanStringConstantLoop; } } break; } } if(this.ch >= TypeScript.LexCodeASCIIChars) { this.seenUnicodeChar = true; } this.nextChar(); } return new TypeScript.StringLiteralToken(this.src.substring(this.startPos, this.pos)); }; Scanner.prototype.scanIdentifier = function () { var hasEscape = false; var isFirstChar = (this.ch == TypeScript.LexCodeBSL); var hasUnicode = false; for(; ; ) { while(lexIdStartTable[this.ch] || LexIsDigit(this.ch) || (this.ch >= TypeScript.LexCodeASCIIChars && this.isValidUnicodeIdentifierChar())) { this.nextChar(); } if(this.ch == TypeScript.LexCodeBSL) { this.nextChar(); if(this.ch == TypeScript.LexCode_u) { this.nextChar(); for(var h = 0; h < 4; h++) { if(this.IsHexDigit(this.ch)) { this.nextChar(); } else { this.reportScannerError("Invalid Unicode escape sequence"); return TypeScript.staticTokens[TypeScript.TokenID.Error]; } } var hexChar = parseInt(this.src.substring(this.pos - 4, this.pos), 16); if(lexIdStartTable[hexChar] || (!isFirstChar && LexIsDigit(hexChar)) || (hexChar >= TypeScript.LexCodeASCIIChars && (LexIsUnicodeIdStart(hexChar) || (!isFirstChar && LexIsUnicodeDigit(hexChar))))) { } else { this.reportScannerError("Invalid identifier character"); return TypeScript.staticTokens[TypeScript.TokenID.Error]; } hasEscape = true; isFirstChar = false; continue; } this.reportScannerError("Invalid Unicode escape sequence"); return TypeScript.staticTokens[TypeScript.TokenID.Error]; } break; } var id; var text = this.src.substring(this.startPos, this.pos); if(!hasEscape && (id = TypeScript.LexKeywordTable.lookup(text)) != null) { return TypeScript.staticTokens[id]; } else { return new TypeScript.IdentifierToken(text, hasEscape); } }; Scanner.prototype.innerScan = function () { var rtok; this.tokenStart(); this.ch = this.peekChar(); start: while(this.pos < this.len) { if(lexIdStartTable[this.ch] || this.ch == TypeScript.LexCodeBSL || (this.ch >= TypeScript.LexCodeASCIIChars && LexIsUnicodeIdStart(this.ch))) { return this.scanIdentifier(); } else { if(this.ch == TypeScript.LexCodeSpace) { if(!this.interveningWhitespace) { this.interveningWhitespacePos = this.pos; } do { this.nextChar(); }while(this.ch == TypeScript.LexCodeSpace) if(this.mode == LexMode.Line) { var whitespaceText = this.src.substring(this.startPos, this.pos); return new TypeScript.WhitespaceToken(TypeScript.TokenID.Whitespace, whitespaceText); } else { this.tokenStart(); this.interveningWhitespace = true; } } else { if(this.ch == TypeScript.LexCodeSLH) { this.nextChar(); var commentText; if(this.ch == TypeScript.LexCodeSLH) { if(!this.interveningWhitespace) { this.interveningWhitespacePos = this.pos - 1; } var commentStartPos = this.pos - 1; var commentStartLine = this.line; this.finishSinglelineComment(); var commentText = this.src.substring(commentStartPos, this.pos); var commentToken = new TypeScript.CommentToken(TypeScript.TokenID.Comment, commentText, false, commentStartPos, commentStartLine, false); if(this.scanComments) { this.startPos = commentStartPos; return commentToken; } else { this.pushComment(commentToken); } this.interveningWhitespace = true; } else { if(this.ch == TypeScript.LexCodeMUL) { if(!this.interveningWhitespace) { this.interveningWhitespacePos = this.pos - 1; } var commentStartPos = this.pos - 1; var commentStartLine = this.line; this.nextChar(); this.finishMultilineComment(); var commentText = this.src.substring(commentStartPos, this.pos); var endsLine = this.endsLine(this.peekChar()); var commentToken = new TypeScript.CommentToken(TypeScript.TokenID.Comment, commentText, true, commentStartPos, commentStartLine, endsLine); if(this.scanComments) { this.startPos = commentStartPos; return commentToken; } else { this.pushComment(commentToken); } this.interveningWhitespace = true; } else { var regexTok = this.speculateRegex(); if(regexTok) { return regexTok; } else { if(this.peekCharAt(this.pos) == TypeScript.LexCodeEQ) { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.SlashEquals]; } else { return TypeScript.staticTokens[TypeScript.TokenID.Slash]; } } } } } else { if(this.ch == TypeScript.LexCodeSMC) { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Semicolon]; } else { if((this.ch == TypeScript.LexCodeAPO) || (this.ch == TypeScript.LexCodeQUO)) { return this.scanStringConstant(); } else { if(autoToken[this.ch]) { var atok = autoToken[this.ch]; if(atok.tokenId == TypeScript.TokenID.OpenBrace) { this.leftCurlyCount++; } else { if(atok.tokenId == TypeScript.TokenID.CloseBrace) { this.rightCurlyCount++; } } this.nextChar(); return atok; } else { if((this.ch >= TypeScript.LexCode_0) && (this.ch <= TypeScript.LexCode_9)) { rtok = this.scanNumber(); if(rtok) { return rtok; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Error]; } } else { switch(this.ch) { case TypeScript.LexCodeTAB: case TypeScript.LexCodeVTAB: { if(!this.interveningWhitespace) { this.interveningWhitespacePos = this.pos; } if(this.mode == LexMode.Line) { do { this.nextChar(); }while((this.ch == TypeScript.LexCodeSpace) || (this.ch == 9)) var wsText = this.src.substring(this.startPos, this.pos); return new TypeScript.WhitespaceToken(TypeScript.TokenID.Whitespace, wsText); } else { this.interveningWhitespace = true; } } case 255: case 254: case 239: case 187: case 191: case TypeScript.LexCodeLS: case TypeScript.LexCodePS: case TypeScript.LexCodeNWL: case TypeScript.LexCodeRET: { if(this.ch == TypeScript.LexCodeNWL) { this.newLine(); if(this.mode == LexMode.Line) { return TypeScript.staticTokens[TypeScript.TokenID.EndOfFile]; } } if(!this.interveningWhitespace) { this.interveningWhitespacePos = this.pos; } this.nextChar(); this.tokenStart(); this.interveningWhitespace = true; break; } case TypeScript.LexCodeDOT: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeDOT) { if(this.peekCharAt(this.pos + 2) == TypeScript.LexCodeDOT) { this.advanceChar(3); return TypeScript.staticTokens[TypeScript.TokenID.DotDotDot]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Dot]; } } else { this.nextChar(); rtok = this.scanFraction(); if(rtok) { return rtok; } else { return TypeScript.staticTokens[TypeScript.TokenID.Dot]; } } } case TypeScript.LexCodeEQ: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { if(this.peekCharAt(this.pos + 2) == TypeScript.LexCodeEQ) { this.advanceChar(3); return TypeScript.staticTokens[TypeScript.TokenID.EqualsEqualsEquals]; } else { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.EqualsEquals]; } } else { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeGT) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.EqualsGreaterThan]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Equals]; } } } case TypeScript.LexCodeBNG: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { if(this.peekCharAt(this.pos + 2) == TypeScript.LexCodeEQ) { this.advanceChar(3); return TypeScript.staticTokens[TypeScript.TokenID.ExclamationEqualsEquals]; } else { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.ExclamationEquals]; } } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Exclamation]; } } case TypeScript.LexCodePLS: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.PlusEquals]; } else { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodePLS) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.PlusPlus]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Plus]; } } } case TypeScript.LexCodeMIN: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.MinusEquals]; } else { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeMIN) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.MinusMinus]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Minus]; } } } case TypeScript.LexCodeMUL: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.AsteriskEquals]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Asterisk]; } } case TypeScript.LexCodePCT: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.PercentEquals]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Percent]; } } case TypeScript.LexCodeLT: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeLT) { if(this.peekCharAt(this.pos + 2) == TypeScript.LexCodeEQ) { this.advanceChar(3); return TypeScript.staticTokens[TypeScript.TokenID.LessThanLessThanEquals]; } else { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.LessThanLessThan]; } } else { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.LessThanEquals]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.LessThan]; } } } case TypeScript.LexCodeGT: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeGT) { if(this.peekCharAt(this.pos + 2) == TypeScript.LexCodeEQ) { this.advanceChar(3); return TypeScript.staticTokens[TypeScript.TokenID.GreaterThanGreaterThanEquals]; } else { if(this.peekCharAt(this.pos + 2) == TypeScript.LexCodeGT) { if(this.peekCharAt(this.pos + 3) == TypeScript.LexCodeEQ) { this.advanceChar(4); return TypeScript.staticTokens[TypeScript.TokenID.GreaterThanGreaterThanGreaterThanEquals]; } else { this.advanceChar(3); return TypeScript.staticTokens[TypeScript.TokenID.GreaterThanGreaterThanGreaterThan]; } } else { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.GreaterThanGreaterThan]; } } } else { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.GreaterThanEquals]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.GreaterThan]; } } } case TypeScript.LexCodeXOR: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.CaretEquals]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Caret]; } } case TypeScript.LexCodeBAR: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.BarEquals]; } else { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeBAR) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.BarBar]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.Bar]; } } } case TypeScript.LexCodeAMP: { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeEQ) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.AmpersandEquals]; } else { if(this.peekCharAt(this.pos + 1) == TypeScript.LexCodeAMP) { this.advanceChar(2); return TypeScript.staticTokens[TypeScript.TokenID.AmpersandAmpersand]; } else { this.nextChar(); return TypeScript.staticTokens[TypeScript.TokenID.And]; } } } default: { this.reportScannerError("Invalid character"); this.nextChar(); continue start; } } } } } } } } } } return TypeScript.staticTokens[TypeScript.TokenID.EndOfFile]; }; Scanner.prototype.reportScannerError = function (message) { if(this.reportError) { this.reportError(message); } }; return Scanner; })(); TypeScript.Scanner = Scanner; function convertTokToIDName(tok) { return convertTokToIDBase(tok, true, false); } TypeScript.convertTokToIDName = convertTokToIDName; function convertTokToID(tok, strictMode) { return convertTokToIDBase(tok, false, strictMode); } TypeScript.convertTokToID = convertTokToID; function convertTokToIDBase(tok, identifierName, strictMode) { if(tok.tokenId <= TypeScript.TokenID.LimKeyword) { var tokInfo = TypeScript.lookupToken(tok.tokenId); if(tokInfo != undefined) { var resFlags = TypeScript.Reservation.Javascript | TypeScript.Reservation.JavascriptFuture; if(strictMode) { resFlags |= TypeScript.Reservation.JavascriptFutureStrict; } if(identifierName || !TypeScript.hasFlag(tokInfo.reservation, resFlags)) { return true; } } else { return false; } } else { return false; } } function getLineNumberFromPosition(lineMap, position) { if(position === -1) { return 0; } var min = 0; var max = lineMap.length - 1; while(min < max) { var med = (min + max) >> 1; if(position < lineMap[med]) { max = med - 1; } else { if(position < lineMap[med + 1]) { min = max = med; } else { min = med + 1; } } } return min; } TypeScript.getLineNumberFromPosition = getLineNumberFromPosition; function getSourceLineColFromMap(lineCol, minChar, lineMap) { var line = getLineNumberFromPosition(lineMap, minChar); if(line > 0) { lineCol.line = line; lineCol.col = (minChar - lineMap[line]); } } TypeScript.getSourceLineColFromMap = getSourceLineColFromMap; function getLineColumnFromPosition(script, position) { var result = { line: -1, col: -1 }; getSourceLineColFromMap(result, position, script.locationInfo.lineMap); if(result.col >= 0) { result.col++; } return result; } TypeScript.getLineColumnFromPosition = getLineColumnFromPosition; function getPositionFromLineColumn(script, line, column) { return script.locationInfo.lineMap[line] + (column - 1); } TypeScript.getPositionFromLineColumn = getPositionFromLineColumn; function isPrimitiveTypeToken(token) { switch(token.tokenId) { case TypeScript.TokenID.Any: case TypeScript.TokenID.Bool: case TypeScript.TokenID.Number: case TypeScript.TokenID.String: { return true; } } return false; } TypeScript.isPrimitiveTypeToken = isPrimitiveTypeToken; function isModifier(token) { switch(token.tokenId) { case TypeScript.TokenID.Public: case TypeScript.TokenID.Private: case TypeScript.TokenID.Static: { return true; } } return false; } TypeScript.isModifier = isModifier; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var AssignScopeContext = (function () { function AssignScopeContext(scopeChain, typeFlow, modDeclChain) { this.scopeChain = scopeChain; this.typeFlow = typeFlow; this.modDeclChain = modDeclChain; } return AssignScopeContext; })(); TypeScript.AssignScopeContext = AssignScopeContext; function pushAssignScope(scope, context, type, classType, fnc) { var chain = new TypeScript.ScopeChain(null, context.scopeChain, scope); chain.thisType = type; chain.classType = classType; chain.fnc = fnc; context.scopeChain = chain; } TypeScript.pushAssignScope = pushAssignScope; function popAssignScope(context) { context.scopeChain = context.scopeChain.previous; } TypeScript.popAssignScope = popAssignScope; function instanceCompare(a, b) { if(((a == null) || (!a.isInstanceProperty()))) { return b; } else { return a; } } TypeScript.instanceCompare = instanceCompare; function instanceFilterStop(s) { return s.isInstanceProperty(); } TypeScript.instanceFilterStop = instanceFilterStop; var ScopeSearchFilter = (function () { function ScopeSearchFilter(select, stop) { this.select = select; this.stop = stop; this.result = null; } ScopeSearchFilter.prototype.reset = function () { this.result = null; }; ScopeSearchFilter.prototype.update = function (b) { this.result = this.select(this.result, b); if(this.result) { return this.stop(this.result); } else { return false; } }; return ScopeSearchFilter; })(); TypeScript.ScopeSearchFilter = ScopeSearchFilter; TypeScript.instanceFilter = new ScopeSearchFilter(instanceCompare, instanceFilterStop); function preAssignModuleScopes(ast, context) { var moduleDecl = ast; var memberScope = null; var aggScope = null; if(moduleDecl.name && moduleDecl.mod) { moduleDecl.name.sym = moduleDecl.mod.symbol; } var mod = moduleDecl.mod; if(!mod) { return; } memberScope = new TypeScript.SymbolTableScope(mod.members, mod.ambientMembers, mod.enclosedTypes, mod.ambientEnclosedTypes, mod.symbol); mod.memberScope = memberScope; context.modDeclChain.push(moduleDecl); context.typeFlow.checker.currentModDecl = moduleDecl; aggScope = new TypeScript.SymbolAggregateScope(mod.symbol); aggScope.addParentScope(memberScope); aggScope.addParentScope(context.scopeChain.scope); pushAssignScope(aggScope, context, null, null, null); mod.containedScope = aggScope; if(mod.symbol) { context.typeFlow.addLocalsFromScope(mod.containedScope, mod.symbol, moduleDecl.vars, mod.members.privateMembers, true); } } TypeScript.preAssignModuleScopes = preAssignModuleScopes; function preAssignClassScopes(ast, context) { var classDecl = ast; var memberScope = null; var aggScope = null; if(classDecl.name && classDecl.type) { classDecl.name.sym = classDecl.type.symbol; } var classType = ast.type; if(classType) { var classSym = classType.symbol; memberScope = context.typeFlow.checker.scopeOf(classType); aggScope = new TypeScript.SymbolAggregateScope(classType.symbol); aggScope.addParentScope(memberScope); aggScope.addParentScope(context.scopeChain.scope); classType.containedScope = aggScope; classType.memberScope = memberScope; var instanceType = classType.instanceType; memberScope = context.typeFlow.checker.scopeOf(instanceType); instanceType.memberScope = memberScope; aggScope = new TypeScript.SymbolAggregateScope(instanceType.symbol); aggScope.addParentScope(context.scopeChain.scope); pushAssignScope(aggScope, context, instanceType, classType, null); instanceType.containedScope = aggScope; } else { ast.type = context.typeFlow.anyType; } } TypeScript.preAssignClassScopes = preAssignClassScopes; function preAssignInterfaceScopes(ast, context) { var interfaceDecl = ast; var memberScope = null; var aggScope = null; if(interfaceDecl.name && interfaceDecl.type) { interfaceDecl.name.sym = interfaceDecl.type.symbol; } var interfaceType = ast.type; memberScope = context.typeFlow.checker.scopeOf(interfaceType); interfaceType.memberScope = memberScope; aggScope = new TypeScript.SymbolAggregateScope(interfaceType.symbol); aggScope.addParentScope(memberScope); aggScope.addParentScope(context.scopeChain.scope); pushAssignScope(aggScope, context, null, null, null); interfaceType.containedScope = aggScope; } TypeScript.preAssignInterfaceScopes = preAssignInterfaceScopes; function preAssignWithScopes(ast, context) { var withStmt = ast; var withType = withStmt.type; var members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); var ambientMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); var withType = new TypeScript.Type(); var withSymbol = new TypeScript.WithSymbol(withStmt.minChar, context.typeFlow.checker.locationInfo.unitIndex, withType); withType.members = members; withType.ambientMembers = ambientMembers; withType.symbol = withSymbol; withType.setHasImplementation(); withStmt.type = withType; var withScope = new TypeScript.SymbolScopeBuilder(withType.members, withType.ambientMembers, null, null, context.scopeChain.scope, withType.symbol); pushAssignScope(withScope, context, null, null, null); withType.containedScope = withScope; } TypeScript.preAssignWithScopes = preAssignWithScopes; function preAssignFuncDeclScopes(ast, context) { var funcDecl = ast; var container = null; var localContainer = null; if(funcDecl.type) { localContainer = ast.type.symbol; } var isStatic = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Static); var isInnerStatic = isStatic && context.scopeChain.fnc != null; var parentScope = isInnerStatic ? context.scopeChain.fnc.type.memberScope : context.scopeChain.scope; if(context.scopeChain.thisType && (!funcDecl.isConstructor || TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod))) { var instType = context.scopeChain.thisType; if(!(instType.typeFlags & TypeScript.TypeFlags.IsClass) && !TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod)) { if(!funcDecl.isMethod() || isStatic) { parentScope = instType.constructorScope; } else { parentScope = instType.containedScope; } } else { if(context.scopeChain.previous.scope.container && context.scopeChain.previous.scope.container.declAST && context.scopeChain.previous.scope.container.declAST.nodeType == TypeScript.NodeType.FuncDecl && (context.scopeChain.previous.scope.container.declAST).isConstructor) { parentScope = instType.constructorScope; } else { if(isStatic && context.scopeChain.classType) { parentScope = context.scopeChain.classType.containedScope; } else { parentScope = instType.containedScope; } } } container = instType.symbol; } else { if(funcDecl.isConstructor && context.scopeChain.thisType) { container = context.scopeChain.thisType.symbol; } } if(funcDecl.type == null || TypeScript.hasFlag(funcDecl.type.symbol.flags, TypeScript.SymbolFlags.TypeSetDuringScopeAssignment)) { if(context.scopeChain.fnc && context.scopeChain.fnc.type) { container = context.scopeChain.fnc.type.symbol; } var funcScope = null; var outerFnc = context.scopeChain.fnc; var nameText = funcDecl.name ? funcDecl.name.actualText : null; var fgSym = null; if(isStatic) { if(outerFnc.type.members == null && container.getType().memberScope) { outerFnc.type.members = ((container).type.memberScope).valueMembers; } funcScope = context.scopeChain.fnc.type.memberScope; outerFnc.innerStaticFuncs[outerFnc.innerStaticFuncs.length] = funcDecl; } else { funcScope = context.scopeChain.scope; } if(nameText && nameText != "__missing" && !funcDecl.isAccessor()) { if(isStatic) { fgSym = funcScope.findLocal(nameText, false, false); } else { fgSym = funcScope.findLocal(nameText, false, false); } } context.typeFlow.checker.createFunctionSignature(funcDecl, container, funcScope, fgSym, fgSym == null); if(!funcDecl.accessorSymbol && (funcDecl.fncFlags & TypeScript.FncFlags.ClassMethod) && container && ((!fgSym || fgSym.declAST.nodeType != TypeScript.NodeType.FuncDecl) && funcDecl.isAccessor()) || (fgSym && fgSym.isAccessor())) { funcDecl.accessorSymbol = context.typeFlow.checker.createAccessorSymbol(funcDecl, fgSym, container.getType(), (funcDecl.isMethod() && isStatic), true, funcScope, container); } funcDecl.type.symbol.flags |= TypeScript.SymbolFlags.TypeSetDuringScopeAssignment; } if(funcDecl.name && funcDecl.type) { funcDecl.name.sym = funcDecl.type.symbol; } funcDecl.scopeType = funcDecl.type; if(funcDecl.isOverload) { return; } var funcTable = new TypeScript.StringHashTable(); var funcMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(funcTable, new TypeScript.StringHashTable())); var ambientFuncTable = new TypeScript.StringHashTable(); var ambientFuncMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(ambientFuncTable, new TypeScript.StringHashTable())); var funcStaticTable = new TypeScript.StringHashTable(); var funcStaticMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(funcStaticTable, new TypeScript.StringHashTable())); var ambientFuncStaticTable = new TypeScript.StringHashTable(); var ambientFuncStaticMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(ambientFuncStaticTable, new TypeScript.StringHashTable())); funcDecl.unitIndex = context.typeFlow.checker.locationInfo.unitIndex; var locals = new TypeScript.SymbolScopeBuilder(funcMembers, ambientFuncMembers, null, null, parentScope, localContainer); var statics = new TypeScript.SymbolScopeBuilder(funcStaticMembers, ambientFuncStaticMembers, null, null, parentScope, null); if(funcDecl.isConstructor && context.scopeChain.thisType) { context.scopeChain.thisType.constructorScope = locals; } funcDecl.symbols = funcTable; if(!funcDecl.isSpecialFn()) { var group = funcDecl.type; var signature = funcDecl.signature; if(!funcDecl.isConstructor) { group.containedScope = locals; locals.container = group.symbol; group.memberScope = statics; statics.container = group.symbol; } funcDecl.enclosingFnc = context.scopeChain.fnc; group.enclosingType = isStatic ? context.scopeChain.classType : context.scopeChain.thisType; var fgSym = ast.type.symbol; if(((funcDecl.fncFlags & TypeScript.FncFlags.Signature) == TypeScript.FncFlags.None) && funcDecl.vars) { context.typeFlow.addLocalsFromScope(locals, fgSym, funcDecl.vars, funcTable, false); context.typeFlow.addLocalsFromScope(statics, fgSym, funcDecl.statics, funcStaticTable, false); } if(signature.parameters) { var len = signature.parameters.length; for(var i = 0; i < len; i++) { var paramSym = signature.parameters[i]; context.typeFlow.checker.resolveTypeLink(locals, paramSym.parameter.typeLink, true); } } context.typeFlow.checker.resolveTypeLink(locals, signature.returnType, funcDecl.isSignature()); } if(!funcDecl.isConstructor || TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod)) { var thisType = (funcDecl.isConstructor && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod)) ? context.scopeChain.thisType : null; pushAssignScope(locals, context, thisType, null, funcDecl); } if(funcDecl.name && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.IsFunctionExpression)) { if(funcDecl.name.sym) { funcTable.add(funcDecl.name.actualText, funcDecl.name.sym); } } } TypeScript.preAssignFuncDeclScopes = preAssignFuncDeclScopes; function preAssignCatchScopes(ast, context) { var catchBlock = ast; if(catchBlock.param) { var catchTable = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); var catchLocals = new TypeScript.SymbolScopeBuilder(catchTable, null, null, null, context.scopeChain.scope, context.scopeChain.scope.container); catchBlock.containedScope = catchLocals; pushAssignScope(catchLocals, context, context.scopeChain.thisType, context.scopeChain.classType, context.scopeChain.fnc); } } TypeScript.preAssignCatchScopes = preAssignCatchScopes; function preAssignScopes(ast, parent, walker) { var context = walker.state; var go = true; if(ast) { if(ast.nodeType == TypeScript.NodeType.List) { var list = ast; list.enclosingScope = context.scopeChain.scope; } else { if(ast.nodeType == TypeScript.NodeType.ModuleDeclaration) { preAssignModuleScopes(ast, context); } else { if(ast.nodeType == TypeScript.NodeType.ClassDeclaration) { preAssignClassScopes(ast, context); } else { if(ast.nodeType == TypeScript.NodeType.InterfaceDeclaration) { preAssignInterfaceScopes(ast, context); } else { if(ast.nodeType == TypeScript.NodeType.With) { preAssignWithScopes(ast, context); } else { if(ast.nodeType == TypeScript.NodeType.FuncDecl) { preAssignFuncDeclScopes(ast, context); } else { if(ast.nodeType == TypeScript.NodeType.Catch) { preAssignCatchScopes(ast, context); } else { if(ast.nodeType == TypeScript.NodeType.TypeRef) { go = false; } } } } } } } } } walker.options.goChildren = go; return ast; } TypeScript.preAssignScopes = preAssignScopes; function postAssignScopes(ast, parent, walker) { var context = walker.state; var go = true; if(ast) { if(ast.nodeType == TypeScript.NodeType.ModuleDeclaration) { var prevModDecl = ast; popAssignScope(context); context.modDeclChain.pop(); if(context.modDeclChain.length >= 1) { context.typeFlow.checker.currentModDecl = context.modDeclChain[context.modDeclChain.length - 1]; } } else { if(ast.nodeType == TypeScript.NodeType.ClassDeclaration) { popAssignScope(context); } else { if(ast.nodeType == TypeScript.NodeType.InterfaceDeclaration) { popAssignScope(context); } else { if(ast.nodeType == TypeScript.NodeType.With) { popAssignScope(context); } else { if(ast.nodeType == TypeScript.NodeType.FuncDecl) { var funcDecl = ast; if((!funcDecl.isConstructor || TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod)) && !funcDecl.isOverload) { popAssignScope(context); } } else { if(ast.nodeType == TypeScript.NodeType.Catch) { var catchBlock = ast; if(catchBlock.param) { popAssignScope(context); } } else { go = false; } } } } } } } walker.options.goChildren = go; return ast; } TypeScript.postAssignScopes = postAssignScopes; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var TypeCollectionContext = (function () { function TypeCollectionContext(scopeChain, checker) { this.scopeChain = scopeChain; this.checker = checker; this.script = null; } return TypeCollectionContext; })(); TypeScript.TypeCollectionContext = TypeCollectionContext; var MemberScopeContext = (function () { function MemberScopeContext(flow, pos, matchFlag) { this.flow = flow; this.pos = pos; this.matchFlag = matchFlag; this.type = null; this.ast = null; this.options = new TypeScript.AstWalkOptions(); } return MemberScopeContext; })(); TypeScript.MemberScopeContext = MemberScopeContext; var EnclosingScopeContext = (function () { function EnclosingScopeContext(logger, script, text, pos, isMemberCompletion) { this.logger = logger; this.script = script; this.text = text; this.pos = pos; this.isMemberCompletion = isMemberCompletion; this.scopeGetter = null; this.objectLiteralScopeGetter = null; this.scopeStartAST = null; this.skipNextFuncDeclForClass = false; this.deepestModuleDecl = null; this.enclosingClassDecl = null; this.enclosingObjectLit = null; this.publicsOnly = true; this.useFullAst = false; } EnclosingScopeContext.prototype.getScope = function () { return this.scopeGetter(); }; EnclosingScopeContext.prototype.getObjectLiteralScope = function () { return this.objectLiteralScopeGetter(); }; EnclosingScopeContext.prototype.getScopeAST = function () { return this.scopeStartAST; }; EnclosingScopeContext.prototype.getScopePosition = function () { return this.scopeStartAST.minChar; }; EnclosingScopeContext.prototype.getScriptFragmentStartAST = function () { return this.scopeStartAST; }; EnclosingScopeContext.prototype.getScriptFragmentPosition = function () { return this.getScriptFragmentStartAST().minChar; }; EnclosingScopeContext.prototype.getScriptFragment = function () { if(this.scriptFragment == null) { var ast = this.getScriptFragmentStartAST(); var minChar = ast.minChar; var limChar = (this.isMemberCompletion ? this.pos : this.pos + 1); this.scriptFragment = TypeScript.quickParse(this.logger, ast, this.text, minChar, limChar, null).Script; } return this.scriptFragment; }; return EnclosingScopeContext; })(); TypeScript.EnclosingScopeContext = EnclosingScopeContext; function preFindMemberScope(ast, parent, walker) { var memScope = walker.state; if(TypeScript.hasFlag(ast.flags, memScope.matchFlag) && ((memScope.pos < 0) || (memScope.pos == ast.limChar))) { memScope.ast = ast; if((ast.type == null) && (memScope.pos >= 0)) { memScope.flow.inScopeTypeCheck(ast, memScope.scope); } memScope.type = ast.type; memScope.options.stopWalk(); } return ast; } TypeScript.preFindMemberScope = preFindMemberScope; function pushTypeCollectionScope(container, valueMembers, ambientValueMembers, enclosedTypes, ambientEnclosedTypes, context, thisType, classType, moduleDecl) { var builder = new TypeScript.SymbolScopeBuilder(valueMembers, ambientValueMembers, enclosedTypes, ambientEnclosedTypes, null, container); var chain = new TypeScript.ScopeChain(container, context.scopeChain, builder); chain.thisType = thisType; chain.classType = classType; chain.moduleDecl = moduleDecl; context.scopeChain = chain; } TypeScript.pushTypeCollectionScope = pushTypeCollectionScope; function popTypeCollectionScope(context) { context.scopeChain = context.scopeChain.previous; } TypeScript.popTypeCollectionScope = popTypeCollectionScope; function preFindEnclosingScope(ast, parent, walker) { var context = walker.state; var minChar = ast.minChar; var limChar = ast.limChar; if(ast.nodeType == TypeScript.NodeType.Script && context.pos > limChar) { limChar = context.pos; } if((minChar <= context.pos) && (limChar >= context.pos)) { switch(ast.nodeType) { case TypeScript.NodeType.Script: { var script = ast; context.scopeGetter = function () { return script.bod === null ? null : script.bod.enclosingScope; }; context.scopeStartAST = script; break; } case TypeScript.NodeType.ClassDeclaration: { context.scopeGetter = function () { return (ast.type === null || ast.type.instanceType.containedScope === null) ? null : ast.type.instanceType.containedScope; }; context.scopeStartAST = ast; context.enclosingClassDecl = ast; break; } case TypeScript.NodeType.ObjectLit: { var objectLit = ast; if(objectLit.targetType) { context.scopeGetter = function () { return objectLit.targetType.containedScope; }; context.objectLiteralScopeGetter = function () { return objectLit.targetType.memberScope; }; context.enclosingObjectLit = objectLit; } break; } case TypeScript.NodeType.ModuleDeclaration: { context.deepestModuleDecl = ast; context.scopeGetter = function () { return ast.type === null ? null : ast.type.containedScope; }; context.scopeStartAST = ast; break; } case TypeScript.NodeType.InterfaceDeclaration: { context.scopeGetter = function () { return (ast.type === null) ? null : ast.type.containedScope; }; context.scopeStartAST = ast; break; } case TypeScript.NodeType.FuncDecl: { { var funcDecl = ast; if(context.skipNextFuncDeclForClass) { context.skipNextFuncDeclForClass = false; } else { context.scopeGetter = function () { if(funcDecl.isConstructor && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod)) { if(ast.type && ast.type.enclosingType) { return ast.type.enclosingType.constructorScope; } } if(funcDecl.scopeType) { return funcDecl.scopeType.containedScope; } if(funcDecl.type) { return funcDecl.type.containedScope; } return null; }; context.scopeStartAST = ast; } } break; } } walker.options.goChildren = true; } else { walker.options.goChildren = false; } return ast; } TypeScript.preFindEnclosingScope = preFindEnclosingScope; function findEnclosingScopeAt(logger, script, text, pos, isMemberCompletion) { var context = new EnclosingScopeContext(logger, script, text, pos, isMemberCompletion); TypeScript.getAstWalkerFactory().walk(script, preFindEnclosingScope, null, null, context); if(context.scopeStartAST === null) { return null; } return context; } TypeScript.findEnclosingScopeAt = findEnclosingScopeAt; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var Signature = (function () { function Signature() { this.hasVariableArgList = false; this.parameters = null; this.declAST = null; this.typeCheckStatus = TypeScript.TypeCheckStatus.NotStarted; this.nonOptionalParameterCount = 0; } Signature.prototype.specializeType = function (pattern, replacement, checker) { var result = new Signature(); if(this.hasVariableArgList) { result.hasVariableArgList = true; } result.returnType = new TypeScript.TypeLink(); if(this.returnType.type) { result.returnType.type = this.returnType.type.specializeType(pattern, replacement, checker, false); } else { result.returnType.type = checker.anyType; } if(this.parameters) { result.parameters = []; for(var i = 0, len = this.parameters.length; i < len; i++) { var oldSym = this.parameters[i]; var paramDef = new TypeScript.ValueLocation(); var paramSym = new TypeScript.ParameterSymbol(oldSym.name, oldSym.location, checker.locationInfo.unitIndex, paramDef); paramSym.declAST = this.declAST; paramDef.symbol = paramSym; paramDef.typeLink = new TypeScript.TypeLink(); result.parameters[i] = paramSym; var oldType = oldSym.getType(); if(oldType) { paramDef.typeLink.type = oldType.specializeType(pattern, replacement, checker, false); paramSym.declAST.type = paramDef.typeLink.type; } else { paramDef.typeLink.type = checker.anyType; } } } result.nonOptionalParameterCount = this.nonOptionalParameterCount; result.declAST = this.declAST; return result; }; Signature.prototype.toString = function () { return this.toStringHelper(false, false, null); }; Signature.prototype.toStringHelper = function (shortform, brackets, scope) { return this.toStringHelperEx(shortform, brackets, scope).toString(); }; Signature.prototype.toStringHelperEx = function (shortform, brackets, scope, prefix) { if (typeof prefix === "undefined") { prefix = ""; } var builder = new TypeScript.MemberNameArray(); if(brackets) { builder.prefix = prefix + "["; } else { builder.prefix = prefix + "("; } var paramLen = this.parameters.length; var len = this.hasVariableArgList ? paramLen - 1 : paramLen; for(var i = 0; i < len; i++) { builder.add(TypeScript.MemberName.create(this.parameters[i].name + (this.parameters[i].isOptional() ? "?" : "") + ": ")); builder.add(this.parameters[i].getType().getScopedTypeNameEx(scope)); if(i < paramLen - 1) { builder.add(TypeScript.MemberName.create(", ")); } } if(this.hasVariableArgList) { builder.add(TypeScript.MemberName.create("..." + this.parameters[i].name + ": ")); builder.add(this.parameters[i].getType().getScopedTypeNameEx(scope)); } if(shortform) { if(brackets) { builder.add(TypeScript.MemberName.create("] => ")); } else { builder.add(TypeScript.MemberName.create(") => ")); } } else { if(brackets) { builder.add(TypeScript.MemberName.create("]: ")); } else { builder.add(TypeScript.MemberName.create("): ")); } } if(this.returnType.type) { builder.add(this.returnType.type.getScopedTypeNameEx(scope)); } else { builder.add(TypeScript.MemberName.create("any")); } return builder; }; return Signature; })(); TypeScript.Signature = Signature; var SignatureGroup = (function () { function SignatureGroup() { this.signatures = []; this.hasImplementation = true; this.definitionSignature = null; this.hasBeenTypechecked = false; this.flags = TypeScript.SignatureFlags.None; } SignatureGroup.prototype.addSignature = function (signature) { if(this.signatures == null) { this.signatures = new Array(); } this.signatures[this.signatures.length] = signature; if(signature.declAST && !signature.declAST.isOverload && !signature.declAST.isSignature() && !TypeScript.hasFlag(signature.declAST.fncFlags, TypeScript.FncFlags.Ambient) && TypeScript.hasFlag(signature.declAST.fncFlags, TypeScript.FncFlags.Definition)) { this.definitionSignature = signature; } }; SignatureGroup.prototype.toString = function () { return this.signatures.toString(); }; SignatureGroup.prototype.toStrings = function (prefix, shortform, scope) { var result = []; var len = this.signatures.length; if(len > 1) { shortform = false; } for(var i = 0; i < len; i++) { if(len > 1 && this.signatures[i] == this.definitionSignature) { continue; } if(this.flags & TypeScript.SignatureFlags.IsIndexer) { result.push(this.signatures[i].toStringHelperEx(shortform, true, scope)); } else { result.push(this.signatures[i].toStringHelperEx(shortform, false, scope, prefix)); } } return result; }; SignatureGroup.prototype.specializeType = function (pattern, replacement, checker) { var result = new SignatureGroup(); if(this.signatures) { for(var i = 0, len = this.signatures.length; i < len; i++) { result.addSignature(this.signatures[i].specializeType(pattern, replacement, checker)); } } return result; }; SignatureGroup.prototype.verifySignatures = function (checker) { var len = 0; if(this.signatures && ((len = this.signatures.length) > 0)) { for(var i = 0; i < len; i++) { for(var j = i + 1; j < len; j++) { if(this.signatures[i].declAST && this.signatures[j].declAST && (!TypeScript.hasFlag(this.signatures[i].declAST.fncFlags, TypeScript.FncFlags.Definition) && !TypeScript.hasFlag(this.signatures[j].declAST.fncFlags, TypeScript.FncFlags.Definition)) && checker.signaturesAreIdentical(this.signatures[i], this.signatures[j])) { checker.errorReporter.simpleError(this.signatures[i].declAST, (this.signatures[i].declAST && this.signatures[i].declAST.name) ? "Signature for '" + this.signatures[i].declAST.name.actualText + "' is duplicated" : "Signature is duplicated"); } } if(this.definitionSignature) { if(!checker.signatureIsAssignableToTarget(this.definitionSignature, this.signatures[i])) { checker.errorReporter.simpleError(this.signatures[i].declAST, "Overload signature is not compatible with function definition"); } } } } }; SignatureGroup.prototype.typeCheck = function (checker, ast, hasConstruct) { if(this.hasBeenTypechecked) { return; } this.hasBeenTypechecked = true; var len = 0; if(this.signatures && ((len = this.signatures.length) > 0)) { for(var i = 0; i < len; i++) { if(!hasConstruct && !this.definitionSignature && this.signatures[i].declAST && this.signatures[i].declAST.isOverload && !TypeScript.hasFlag(this.signatures[i].declAST.fncFlags, TypeScript.FncFlags.Ambient)) { checker.errorReporter.simpleError(this.signatures[i].declAST, "Overload declaration lacks definition"); } if(this.signatures[i].declAST && this.signatures[i].declAST.isConstructor && this.signatures[i].declAST.classDecl && this.signatures[i].declAST.classDecl.type.symbol.typeCheckStatus == TypeScript.TypeCheckStatus.NotStarted) { checker.typeFlow.typeCheck(this.signatures[i].declAST.classDecl); } checker.typeFlow.typeCheck(this.signatures[i].declAST); } this.verifySignatures(checker); } }; return SignatureGroup; })(); TypeScript.SignatureGroup = SignatureGroup; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { (function (TypeCheckStatus) { TypeCheckStatus._map = []; TypeCheckStatus._map[0] = "NotStarted"; TypeCheckStatus.NotStarted = 0; TypeCheckStatus._map[1] = "Started"; TypeCheckStatus.Started = 1; TypeCheckStatus._map[2] = "Finished"; TypeCheckStatus.Finished = 2; })(TypeScript.TypeCheckStatus || (TypeScript.TypeCheckStatus = {})); var TypeCheckStatus = TypeScript.TypeCheckStatus; function aLexicallyEnclosesB(a, b) { if(a.declAST && b && b.declAST && a.declAST.nodeType == TypeScript.NodeType.FuncDecl) { return a.declAST.minChar <= b.declAST.minChar && a.declAST.limChar >= b.declAST.limChar; } else { return false; } } TypeScript.aLexicallyEnclosesB = aLexicallyEnclosesB; function aEnclosesB(a, b) { while(a.container) { if(a == b || aLexicallyEnclosesB(a.container, b)) { return true; } a = a.container; } return false; } TypeScript.aEnclosesB = aEnclosesB; var Symbol = (function () { function Symbol(name, location, length, unitIndex) { this.name = name; this.location = location; this.length = length; this.unitIndex = unitIndex; this.bound = false; this.flags = TypeScript.SymbolFlags.None; this.isObjectLitField = false; this.declAST = null; this.declModule = null; this.passSymbolCreated = TypeScript.CompilerDiagnostics.analysisPass; } Symbol.prototype.instanceScope = function () { return null; }; Symbol.prototype.isVariable = function () { return false; }; Symbol.prototype.isMember = function () { return false; }; Symbol.prototype.isInferenceSymbol = function () { return false; }; Symbol.prototype.isWith = function () { return false; }; Symbol.prototype.writeable = function () { return false; }; Symbol.prototype.isType = function () { return false; }; Symbol.prototype.getType = function () { return null; }; Symbol.prototype.isAccessor = function () { return false; }; Symbol.prototype.isInstanceProperty = function () { return TypeScript.hasFlag(this.flags, TypeScript.SymbolFlags.Property) && (!TypeScript.hasFlag(this.flags, TypeScript.SymbolFlags.ModuleMember)); }; Symbol.prototype.getTypeName = function (scope) { return this.getTypeNameEx(scope).toString(); }; Symbol.prototype.getTypeNameEx = function (scope) { return TypeScript.MemberName.create(this.toString()); }; Symbol.prototype.getOptionalNameString = function () { return TypeScript.hasFlag(this.flags, TypeScript.SymbolFlags.Optional) ? "?" : ""; }; Symbol.prototype.pathToRoot = function () { var path = new Array(); var node = this; while(node && (node.name != TypeScript.globalId)) { path[path.length] = node; node = node.container; } return path; }; Symbol.prototype.findCommonAncestorPath = function (b) { if(this.container == null) { return new Array(); } var aPath = this.container.pathToRoot(); var bPath; if(b) { bPath = b.pathToRoot(); } else { bPath = new Array(); } var commonNodeIndex = -1; for(var i = 0, aLen = aPath.length; i < aLen; i++) { var aNode = aPath[i]; for(var j = 0, bLen = bPath.length; j < bLen; j++) { var bNode = bPath[j]; if(aNode == bNode) { commonNodeIndex = i; break; } } if(commonNodeIndex >= 0) { break; } } if(commonNodeIndex >= 0) { return aPath.slice(0, commonNodeIndex); } else { return aPath; } }; Symbol.prototype.getPrettyName = function (scopeSymbol) { return this.name; }; Symbol.prototype.scopeRelativeName = function (scope) { if(scope == null) { return this.getPrettyName(null) + this.getOptionalNameString(); } var lca = this.findCommonAncestorPath(scope.container); var builder = ""; for(var i = 0, len = lca.length; i < len; i++) { var prettyName = lca[i].getPrettyName(i == len - 1 ? scope.container : lca[i + 1]); builder = prettyName + "." + builder; } builder += this.getPrettyName(len == 0 ? scope.container : lca[0]) + this.getOptionalNameString(); return builder; }; Symbol.prototype.fullName = function () { var builder = this.name; var ancestor = this.container; while(ancestor && (ancestor.name != TypeScript.globalId)) { builder = ancestor.name + "." + builder; ancestor = ancestor.container; } return builder; }; Symbol.prototype.isExternallyVisible = function (checker) { if(this == checker.gloMod) { return true; } if(TypeScript.hasFlag(this.flags, TypeScript.SymbolFlags.Private)) { return false; } if(!TypeScript.hasFlag(this.flags, TypeScript.SymbolFlags.Exported)) { return this.container == checker.gloMod; } return this.container.isExternallyVisible(checker); }; Symbol.prototype.visible = function (scope, checker) { if(checker == null || this.container == checker.gloMod) { return true; } if(TypeScript.hasFlag(this.flags, TypeScript.SymbolFlags.ModuleMember)) { if(TypeScript.hasFlag(this.flags, TypeScript.SymbolFlags.Exported)) { if(!TypeScript.hasFlag(this.flags, TypeScript.SymbolFlags.Private)) { return true; } else { return aEnclosesB(this, scope.container); } } else { return checker && (checker.currentModDecl == this.declModule) || (checker.currentModDecl && checker.currentModDecl.mod && checker.currentModDecl.mod.symbol && this.declModule && this.declModule.mod && this.declModule.mod.symbol && aEnclosesB(checker.currentModDecl.mod.symbol, this.declModule.mod.symbol)); } } else { var isFunction = this.declAST && this.declAST.nodeType == TypeScript.NodeType.FuncDecl; var isMethod = isFunction && (this.declAST).isMethod(); var isStaticFunction = isFunction && TypeScript.hasFlag((this.declAST).fncFlags, TypeScript.FncFlags.Static); var isPrivateMethod = isMethod && TypeScript.hasFlag((this.declAST).fncFlags, TypeScript.FncFlags.Private); var isAlias = this.isType() && (this).aliasLink; if(this.isMember() || isMethod || isStaticFunction || isAlias) { if(TypeScript.hasFlag(this.flags, TypeScript.SymbolFlags.Private) || isPrivateMethod) { if(scope.container == null && this.container != scope.container) { return false; } else { return this.container == null ? true : aEnclosesB(scope.container, this.container); } } else { return true; } } else { if(this.container) { return aEnclosesB(this, scope.container); } else { return true; } } } }; Symbol.prototype.addRef = function (identifier) { if(!this.refs) { this.refs = []; } this.refs[this.refs.length] = identifier; }; Symbol.prototype.toString = function () { if(this.name) { return this.name; } else { return "_anonymous"; } }; Symbol.prototype.print = function (outfile) { outfile.Write(this.toString()); }; Symbol.prototype.specializeType = function (pattern, replacement, checker) { throw new Error("please implement in derived class"); }; Symbol.prototype.setType = function (type) { throw new Error("please implement in derived class"); }; Symbol.prototype.kind = function () { throw new Error("please implement in derived class"); }; Symbol.prototype.getInterfaceDeclFromSymbol = function (checker) { if(this.declAST != null) { if(this.declAST.nodeType == TypeScript.NodeType.InterfaceDeclaration) { return this.declAST; } else { if(this.container != null && this.container != checker.gloMod && this.container.declAST.nodeType == TypeScript.NodeType.InterfaceDeclaration) { return this.container.declAST; } } } return null; }; Symbol.prototype.getVarDeclFromSymbol = function () { if(this.declAST != null && this.declAST.nodeType == TypeScript.NodeType.VarDecl) { return this.declAST; } return null; }; Symbol.prototype.getDocComments = function () { if(this.declAST != null) { return this.declAST.getDocComments(); } return []; }; Symbol.prototype.isStatic = function () { return TypeScript.hasFlag(this.flags, TypeScript.SymbolFlags.Static); }; return Symbol; })(); TypeScript.Symbol = Symbol; var ValueLocation = (function () { function ValueLocation() { } return ValueLocation; })(); TypeScript.ValueLocation = ValueLocation; var InferenceSymbol = (function (_super) { __extends(InferenceSymbol, _super); function InferenceSymbol(name, location, length, unitIndex) { _super.call(this, name, location, length, unitIndex); this.typeCheckStatus = TypeCheckStatus.NotStarted; } InferenceSymbol.prototype.isInferenceSymbol = function () { return true; }; InferenceSymbol.prototype.transferVarFlags = function (varFlags) { if(TypeScript.hasFlag(varFlags, TypeScript.VarFlags.Ambient)) { this.flags |= TypeScript.SymbolFlags.Ambient; } if(TypeScript.hasFlag(varFlags, TypeScript.VarFlags.Constant)) { this.flags |= TypeScript.SymbolFlags.Constant; } if(TypeScript.hasFlag(varFlags, TypeScript.VarFlags.Static)) { this.flags |= TypeScript.SymbolFlags.Static; } if(TypeScript.hasFlag(varFlags, TypeScript.VarFlags.Property)) { this.flags |= TypeScript.SymbolFlags.Property; } if(TypeScript.hasFlag(varFlags, TypeScript.VarFlags.Private)) { this.flags |= TypeScript.SymbolFlags.Private; } if(TypeScript.hasFlag(varFlags, TypeScript.VarFlags.Public)) { this.flags |= TypeScript.SymbolFlags.Public; } if(TypeScript.hasFlag(varFlags, TypeScript.VarFlags.Readonly)) { this.flags |= TypeScript.SymbolFlags.Readonly; } if(TypeScript.hasFlag(varFlags, TypeScript.VarFlags.Exported)) { this.flags |= TypeScript.SymbolFlags.Exported; } }; return InferenceSymbol; })(Symbol); TypeScript.InferenceSymbol = InferenceSymbol; var TypeSymbol = (function (_super) { __extends(TypeSymbol, _super); function TypeSymbol(locName, location, length, unitIndex, type) { _super.call(this, locName, location, length, unitIndex); this.type = type; this.expansions = []; this.expansionsDeclAST = []; this.isDynamic = false; this.isMethod = false; this.aliasLink = null; this.onlyReferencedAsTypeRef = TypeScript.optimizeModuleCodeGen; this.prettyName = this.name; } TypeSymbol.prototype.addLocation = function (loc) { if(this.additionalLocations == null) { this.additionalLocations = []; } this.additionalLocations[this.additionalLocations.length] = loc; }; TypeSymbol.prototype.kind = function () { return TypeScript.SymbolKind.Type; }; TypeSymbol.prototype.isType = function () { return true; }; TypeSymbol.prototype.getType = function () { return this.type; }; TypeSymbol.prototype.getTypeNameEx = function (scope) { return this.type.getMemberTypeNameEx(this.name ? this.name + this.getOptionalNameString() : "", false, false, scope); }; TypeSymbol.prototype.instanceScope = function () { if(!(this.type.typeFlags & TypeScript.TypeFlags.IsClass) && this.type.isClass()) { return this.type.instanceType.constructorScope; } else { return this.type.containedScope; } }; TypeSymbol.prototype.toString = function () { var result = this.type.getTypeName(); if(this.name) { result = this.name + ":" + result; } return result; }; TypeSymbol.prototype.isClass = function () { return this.instanceType != null; }; TypeSymbol.prototype.isFunction = function () { return this.declAST != null && this.declAST.nodeType == TypeScript.NodeType.FuncDecl; }; TypeSymbol.prototype.specializeType = function (pattern, replacement, checker) { if(this.type == pattern) { return replacement.symbol; } else { var replType = this.type.specializeType(pattern, replacement, checker, false); if(replType != this.type) { var result = new TypeSymbol(this.name, -1, 0, -1, replType); return result; } else { return this; } } }; TypeSymbol.prototype.getPrettyName = function (scopeSymbol) { if(!!scopeSymbol && TypeScript.isQuoted(this.prettyName) && this.type.isModuleType()) { var symbolPath = scopeSymbol.pathToRoot(); var prettyName = this.getPrettyNameOfDynamicModule(symbolPath); if(prettyName != null) { return prettyName.name; } } return this.prettyName; }; TypeSymbol.prototype.getPrettyNameOfDynamicModule = function (scopeSymbolPath) { var scopeSymbolPathLength = scopeSymbolPath.length; var externalSymbol = null; if(scopeSymbolPath.length > 0 && scopeSymbolPath[scopeSymbolPathLength - 1].getType().isModuleType() && (scopeSymbolPath[scopeSymbolPathLength - 1]).isDynamic) { if(scopeSymbolPathLength > 1 && scopeSymbolPath[scopeSymbolPathLength - 2].getType().isModuleType() && (scopeSymbolPath[scopeSymbolPathLength - 2]).isDynamic) { var moduleType = scopeSymbolPath[scopeSymbolPathLength - 2].getType(); externalSymbol = moduleType.findDynamicModuleName(this.type); } if(externalSymbol == null) { var moduleType = scopeSymbolPath[scopeSymbolPathLength - 1].getType(); externalSymbol = moduleType.findDynamicModuleName(this.type); } } return externalSymbol; }; TypeSymbol.prototype.getDocComments = function () { var comments = []; if(this.declAST != null) { comments = comments.concat(this.declAST.getDocComments()); } for(var i = 0; i < this.expansionsDeclAST.length; i++) { comments = comments.concat(this.expansionsDeclAST[i].getDocComments()); } return comments; }; return TypeSymbol; })(InferenceSymbol); TypeScript.TypeSymbol = TypeSymbol; var WithSymbol = (function (_super) { __extends(WithSymbol, _super); function WithSymbol(location, unitIndex, withType) { _super.call(this, "with", location, 4, unitIndex, withType); } WithSymbol.prototype.isWith = function () { return true; }; return WithSymbol; })(TypeSymbol); TypeScript.WithSymbol = WithSymbol; var FieldSymbol = (function (_super) { __extends(FieldSymbol, _super); function FieldSymbol(name, location, unitIndex, canWrite, field) { _super.call(this, name, location, name.length, unitIndex); this.canWrite = canWrite; this.field = field; this.getter = null; this.setter = null; this.hasBeenEmitted = false; this.name = name; this.location = location; } FieldSymbol.prototype.kind = function () { return TypeScript.SymbolKind.Field; }; FieldSymbol.prototype.writeable = function () { return this.isAccessor() ? this.setter != null : this.canWrite; }; FieldSymbol.prototype.getType = function () { return this.field.typeLink.type; }; FieldSymbol.prototype.getTypeNameEx = function (scope) { return TypeScript.MemberName.create(this.field.typeLink.type.getScopedTypeNameEx(scope), this.name + this.getOptionalNameString() + ": ", ""); }; FieldSymbol.prototype.isMember = function () { return true; }; FieldSymbol.prototype.setType = function (type) { this.field.typeLink.type = type; }; FieldSymbol.prototype.isAccessor = function () { return this.getter != null || this.setter != null; }; FieldSymbol.prototype.isVariable = function () { return true; }; FieldSymbol.prototype.toString = function () { return this.getTypeNameEx(null).toString(); }; FieldSymbol.prototype.specializeType = function (pattern, replacement, checker) { var rType = this.field.typeLink.type.specializeType(pattern, replacement, checker, false); if(rType != this.field.typeLink.type) { var fieldDef = new ValueLocation(); var result = new FieldSymbol(this.name, 0, checker.locationInfo.unitIndex, this.canWrite, fieldDef); result.flags = this.flags; fieldDef.symbol = result; fieldDef.typeLink = new TypeScript.TypeLink(); result.setType(rType); result.typeCheckStatus = TypeCheckStatus.Finished; return result; } else { return this; } }; FieldSymbol.prototype.getDocComments = function () { if(this.getter != null || this.setter != null) { var comments = []; if(this.getter != null) { comments = comments.concat(this.getter.getDocComments()); } if(this.setter != null) { comments = comments.concat(this.setter.getDocComments()); } return comments; } else { if(this.declAST != null) { return this.declAST.getDocComments(); } } return []; }; return FieldSymbol; })(InferenceSymbol); TypeScript.FieldSymbol = FieldSymbol; var ParameterSymbol = (function (_super) { __extends(ParameterSymbol, _super); function ParameterSymbol(name, location, unitIndex, parameter) { _super.call(this, name, location, name.length, unitIndex); this.parameter = parameter; this.paramDocComment = null; this.funcDecl = null; this.argsOffset = (-1); this.name = name; this.location = location; } ParameterSymbol.prototype.kind = function () { return TypeScript.SymbolKind.Parameter; }; ParameterSymbol.prototype.writeable = function () { return true; }; ParameterSymbol.prototype.getType = function () { return this.parameter.typeLink.type; }; ParameterSymbol.prototype.setType = function (type) { this.parameter.typeLink.type = type; }; ParameterSymbol.prototype.isVariable = function () { return true; }; ParameterSymbol.prototype.isOptional = function () { if(this.parameter && this.parameter.symbol && this.parameter.symbol.declAST) { return (this.parameter.symbol.declAST).isOptional; } else { return false; } }; ParameterSymbol.prototype.getTypeNameEx = function (scope) { return TypeScript.MemberName.create(this.getType().getScopedTypeNameEx(scope), this.name + (this.isOptional() ? "?" : "") + ": ", ""); }; ParameterSymbol.prototype.toString = function () { return this.getTypeNameEx(null).toString(); }; ParameterSymbol.prototype.specializeType = function (pattern, replacement, checker) { var rType = this.parameter.typeLink.type.specializeType(pattern, replacement, checker, false); if(this.parameter.typeLink.type != rType) { var paramDef = new ValueLocation(); var result = new ParameterSymbol(this.name, 0, checker.locationInfo.unitIndex, paramDef); paramDef.symbol = result; result.setType(rType); return result; } else { return this; } }; ParameterSymbol.prototype.getParameterDocComments = function () { if(!this.paramDocComment) { var parameterComments = []; if(this.funcDecl) { var fncDocComments = this.funcDecl.getDocComments(); var paramComment = TypeScript.Comment.getParameterDocCommentText(this.name, fncDocComments); if(paramComment != "") { parameterComments.push(paramComment); } } var docComments = TypeScript.Comment.getDocCommentText(this.getDocComments()); if(docComments != "") { parameterComments.push(docComments); } this.paramDocComment = parameterComments.join("\n"); } return this.paramDocComment; }; return ParameterSymbol; })(InferenceSymbol); TypeScript.ParameterSymbol = ParameterSymbol; var VariableSymbol = (function (_super) { __extends(VariableSymbol, _super); function VariableSymbol(name, location, unitIndex, variable) { _super.call(this, name, location, name.length, unitIndex); this.variable = variable; } VariableSymbol.prototype.kind = function () { return TypeScript.SymbolKind.Variable; }; VariableSymbol.prototype.writeable = function () { return true; }; VariableSymbol.prototype.getType = function () { return this.variable.typeLink.type; }; VariableSymbol.prototype.getTypeNameEx = function (scope) { return TypeScript.MemberName.create(this.getType().getScopedTypeNameEx(scope), this.name + ": ", ""); }; VariableSymbol.prototype.setType = function (type) { this.variable.typeLink.type = type; }; VariableSymbol.prototype.isVariable = function () { return true; }; return VariableSymbol; })(InferenceSymbol); TypeScript.VariableSymbol = VariableSymbol; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var ScopedMembers = (function () { function ScopedMembers(dualMembers) { this.dualMembers = dualMembers; this.allMembers = this.dualMembers; this.publicMembers = this.dualMembers.primaryTable; this.privateMembers = this.dualMembers.secondaryTable; } ScopedMembers.prototype.addPublicMember = function (key, data) { return this.dualMembers.primaryTable.add(key, data); }; ScopedMembers.prototype.addPrivateMember = function (key, data) { return this.dualMembers.secondaryTable.add(key, data); }; return ScopedMembers; })(); TypeScript.ScopedMembers = ScopedMembers; (function (SymbolKind) { SymbolKind._map = []; SymbolKind._map[0] = "None"; SymbolKind.None = 0; SymbolKind._map[1] = "Type"; SymbolKind.Type = 1; SymbolKind._map[2] = "Field"; SymbolKind.Field = 2; SymbolKind._map[3] = "Parameter"; SymbolKind.Parameter = 3; SymbolKind._map[4] = "Variable"; SymbolKind.Variable = 4; })(TypeScript.SymbolKind || (TypeScript.SymbolKind = {})); var SymbolKind = TypeScript.SymbolKind; var SymbolScope = (function () { function SymbolScope(container) { this.container = container; } SymbolScope.prototype.printLabel = function () { return "base"; }; SymbolScope.prototype.getAllSymbolNames = function (members) { return [ "please", "implement", "in", "derived", "classes" ]; }; SymbolScope.prototype.getAllTypeSymbolNames = function (members) { return [ "please", "implement", "in", "derived", "classes" ]; }; SymbolScope.prototype.getAllValueSymbolNames = function (members) { return [ "please", "implement", "in", "derived", "classes" ]; }; SymbolScope.prototype.search = function (filter, name, publicOnly, typespace) { return null; }; SymbolScope.prototype.findLocal = function (name, publicOnly, typespace) { return null; }; SymbolScope.prototype.find = function (name, publicOnly, typespace) { return null; }; SymbolScope.prototype.findImplementation = function (name, publicOnly, typespace) { return null; }; SymbolScope.prototype.findAmbient = function (name, publicOnly, typespace) { return null; }; SymbolScope.prototype.print = function (outfile) { if(this.container) { outfile.WriteLine(this.printLabel() + " scope with container: " + this.container.name + "..."); } else { outfile.WriteLine(this.printLabel() + " scope..."); } }; SymbolScope.prototype.enter = function (container, ast, symbol, errorReporter, publicOnly, typespace, ambient) { throw new Error("please implement in derived class"); }; SymbolScope.prototype.getTable = function () { throw new Error("please implement in derived class"); }; return SymbolScope; })(); TypeScript.SymbolScope = SymbolScope; function symbolCanBeUsed(sym, publicOnly) { return publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true; } var SymbolAggregateScope = (function (_super) { __extends(SymbolAggregateScope, _super); function SymbolAggregateScope(container) { _super.call(this, container); this.valueCache = null; this.valueImplCache = null; this.valueAmbientCache = null; this.typeCache = null; this.typeImplCache = null; this.typeAmbientCache = null; this.parents = null; this.container = container; } SymbolAggregateScope.prototype.printLabel = function () { return "agg"; }; SymbolAggregateScope.prototype.search = function (filter, name, publicOnly, typespace) { if(this.parents) { for(var i = 0; i < this.parents.length; i++) { var sym = this.parents[i].search(filter, name, publicOnly, typespace); if(sym) { if(filter.update(sym)) { return sym; } } } } return filter.result; }; SymbolAggregateScope.prototype.getAllSymbolNames = function (members) { var result = []; if(this.parents) { for(var i = 0; i < this.parents.length; i++) { var parentResult = this.parents[i].getAllSymbolNames(members); if(parentResult) { result = result.concat(parentResult); } } } return result; }; SymbolAggregateScope.prototype.getAllTypeSymbolNames = function (members) { var result = []; if(this.parents) { for(var i = 0; i < this.parents.length; i++) { var parentResult = this.parents[i].getAllTypeSymbolNames(members); if(parentResult) { result = result.concat(parentResult); } } } return result; }; SymbolAggregateScope.prototype.getAllValueSymbolNames = function (members) { var result = []; if(this.parents) { for(var i = 0; i < this.parents.length; i++) { var parentResult = this.parents[i].getAllValueSymbolNames(members); if(parentResult) { result = result.concat(parentResult); } } } return result; }; SymbolAggregateScope.prototype.print = function (outfile) { _super.prototype.print.call(this, outfile); if(this.parents) { for(var i = 0; i < this.parents.length; i++) { this.parents[i].print(outfile); } } }; SymbolAggregateScope.prototype.findImplementation = function (name, publicOnly, typespace) { var sym = null; var i = 0; var implCache = this.valueImplCache; if(typespace) { implCache = this.typeImplCache; } if(implCache && ((sym = implCache.lookup(name)) != null) && (publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true)) { return sym; } if(this.parents) { for(i = 0; i < this.parents.length; i++) { sym = this.parents[i].findImplementation(name, publicOnly, typespace); if(sym) { break; } } } if(implCache) { if(typespace) { this.typeImplCache = new TypeScript.StringHashTable(); implCache = this.typeImplCache; } else { this.valueImplCache = new TypeScript.StringHashTable(); implCache = this.valueImplCache; } } implCache.add(name, sym); return sym; }; SymbolAggregateScope.prototype.find = function (name, publicOnly, typespace) { var sym = null; var i = 0; var cache = this.valueCache; if(typespace) { cache = this.typeCache; } if(cache && ((sym = cache.lookup(name)) != null) && (publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true)) { return sym; } if(this.parents) { for(i = 0; i < this.parents.length; i++) { sym = this.parents[i].find(name, publicOnly, typespace); if(sym) { break; } } } if(cache == null) { if(typespace) { this.typeCache = new TypeScript.StringHashTable(); cache = this.typeCache; } else { this.valueCache = new TypeScript.StringHashTable(); cache = this.valueCache; } } cache.add(name, sym); return sym; }; SymbolAggregateScope.prototype.findAmbient = function (name, publicOnly, typespace) { var sym = null; var i = 0; var cache = this.valueAmbientCache; if(typespace) { cache = this.typeAmbientCache; } if(cache && ((sym = cache.lookup(name)) != null)) { return sym; } if(this.parents) { for(i = 0; i < this.parents.length; i++) { sym = this.parents[i].findAmbient(name, publicOnly, typespace); if(sym) { break; } } } if(cache == null) { if(typespace) { this.typeAmbientCache = new TypeScript.StringHashTable(); cache = this.typeAmbientCache; } else { this.valueAmbientCache = new TypeScript.StringHashTable(); cache = this.valueAmbientCache; } } cache.add(name, sym); return sym; }; SymbolAggregateScope.prototype.addParentScope = function (parent) { if(this.parents == null) { this.parents = new Array(); } this.parents[this.parents.length] = parent; }; return SymbolAggregateScope; })(SymbolScope); TypeScript.SymbolAggregateScope = SymbolAggregateScope; var SymbolTableScope = (function (_super) { __extends(SymbolTableScope, _super); function SymbolTableScope(valueMembers, ambientValueMembers, enclosedTypes, ambientEnclosedTypes, container) { _super.call(this, container); this.valueMembers = valueMembers; this.ambientValueMembers = ambientValueMembers; this.enclosedTypes = enclosedTypes; this.ambientEnclosedTypes = ambientEnclosedTypes; this.container = container; } SymbolTableScope.prototype.printLabel = function () { return "table"; }; SymbolTableScope.prototype.getAllSymbolNames = function (members) { var result = this.getAllTypeSymbolNames(members); return result.concat(this.getAllValueSymbolNames(members)); }; SymbolTableScope.prototype.getAllTypeSymbolNames = function (members) { var result = []; if(this.ambientEnclosedTypes) { result = result.concat(this.ambientEnclosedTypes.allMembers.getAllKeys()); } if(this.enclosedTypes) { result = result.concat(this.enclosedTypes.allMembers.getAllKeys()); } return result; }; SymbolTableScope.prototype.getAllValueSymbolNames = function (members) { var result = []; if(this.ambientValueMembers) { result = result.concat(this.ambientValueMembers.allMembers.getAllKeys()); } if(this.valueMembers) { result = result.concat(this.valueMembers.allMembers.getAllKeys()); } return result; }; SymbolTableScope.prototype.search = function (filter, name, publicOnly, typespace) { var sym = this.find(name, publicOnly, typespace); filter.update(sym); return filter.result; }; SymbolTableScope.prototype.find = function (name, publicOnly, typespace) { var table = null; var ambientTable = null; if(typespace) { table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers; ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers; } else { table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers; ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers; } if(ambientTable) { var s = ambientTable.lookup(name); if(s) { return s; } } if(table) { var s = table.lookup(name); if(s) { return s; } } return null; }; SymbolTableScope.prototype.findAmbient = function (name, publicOnly, typespace) { var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers; if(typespace) { ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers; } if(ambientTable) { var s = ambientTable.lookup(name); if(s) { return s; } } return null; }; SymbolTableScope.prototype.print = function (outfile) { _super.prototype.print.call(this, outfile); if(this.ambientValueMembers) { this.ambientValueMembers.allMembers.map(function (key, sym, context) { outfile.WriteLine(" " + key); }, null); } if(this.valueMembers) { this.valueMembers.allMembers.map(function (key, sym, context) { outfile.WriteLine(" " + key); }, null); } if(this.ambientEnclosedTypes) { this.ambientEnclosedTypes.allMembers.map(function (key, sym, context) { outfile.WriteLine(" " + key); }, null); } if(this.enclosedTypes) { this.enclosedTypes.allMembers.map(function (key, sym, context) { outfile.WriteLine(" " + key); }, null); } }; SymbolTableScope.prototype.findImplementation = function (name, publicOnly, typespace) { var sym = this.find(name, publicOnly, typespace); if(sym) { if(sym.kind() == SymbolKind.Type) { var typeSym = sym; if(!typeSym.type.hasImplementation()) { sym = null; } } else { if(sym.container) { if(sym.container.kind() == SymbolKind.Type) { var ctypeSym = sym.container; if(!ctypeSym.type.hasImplementation()) { sym = null; } } } } } return sym; }; SymbolTableScope.prototype.getTable = function () { return this.valueMembers.publicMembers; }; return SymbolTableScope; })(SymbolScope); TypeScript.SymbolTableScope = SymbolTableScope; var SymbolScopeBuilder = (function (_super) { __extends(SymbolScopeBuilder, _super); function SymbolScopeBuilder(valueMembers, ambientValueMembers, enclosedTypes, ambientEnclosedTypes, parent, container) { _super.call(this, container); this.valueMembers = valueMembers; this.ambientValueMembers = ambientValueMembers; this.enclosedTypes = enclosedTypes; this.ambientEnclosedTypes = ambientEnclosedTypes; this.parent = parent; this.container = container; } SymbolScopeBuilder.prototype.printLabel = function () { return "builder"; }; SymbolScopeBuilder.prototype.getAllSymbolNames = function (members) { var result = this.getAllTypeSymbolNames(members); return result.concat(this.getAllValueSymbolNames(members)); }; SymbolScopeBuilder.prototype.getAllTypeSymbolNames = function (members) { var result = []; if(this.ambientEnclosedTypes) { result = result.concat(this.ambientEnclosedTypes.allMembers.getAllKeys()); } if(this.enclosedTypes) { result = result.concat(this.enclosedTypes.allMembers.getAllKeys()); } if(!members && this.parent) { var parentResult = this.parent.getAllTypeSymbolNames(members); if(parentResult) { result = result.concat(parentResult); } } return result; }; SymbolScopeBuilder.prototype.getAllValueSymbolNames = function (members) { var result = []; if(this.ambientValueMembers) { result = result.concat(this.ambientValueMembers.allMembers.getAllKeys()); } if(this.valueMembers) { result = result.concat(this.valueMembers.allMembers.getAllKeys()); } if(!members && this.parent) { var parentResult = this.parent.getAllValueSymbolNames(members); if(parentResult) { result = result.concat(parentResult); } } return result; }; SymbolScopeBuilder.prototype.search = function (filter, name, publicOnly, typespace) { var sym = null; var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers; var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers; if(typespace) { table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers; ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers; } if(ambientTable) { if((sym = ambientTable.lookup(name)) != null) { if(filter.update(sym)) { return sym; } } } if(table) { if((sym = table.lookup(name)) != null) { if(filter.update(sym)) { return sym; } } } if(this.parent) { sym = this.parent.search(filter, name, publicOnly, typespace); if(sym) { if(filter.update(sym)) { return sym; } } } return filter.result; }; SymbolScopeBuilder.prototype.print = function (outfile) { _super.prototype.print.call(this, outfile); if(this.ambientValueMembers) { this.ambientValueMembers.allMembers.map(function (key, s, context) { var sym = s; outfile.WriteLine(" " + key); }, null); } if(this.valueMembers) { this.valueMembers.allMembers.map(function (key, s, context) { var sym = s; outfile.WriteLine(" " + key); }, null); } if(this.ambientEnclosedTypes) { this.ambientEnclosedTypes.allMembers.map(function (key, s, context) { var sym = s; outfile.WriteLine(" " + key); }, null); } if(this.enclosedTypes) { this.enclosedTypes.allMembers.map(function (key, s, context) { var sym = s; outfile.WriteLine(" " + key); }, null); } if(this.parent) { this.parent.print(outfile); } }; SymbolScopeBuilder.prototype.find = function (name, publicOnly, typespace) { var sym = null; var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers; var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers; if(typespace) { table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers; ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers; } if(ambientTable && ((sym = ambientTable.lookup(name)) != null)) { return sym; } if(table && ((sym = table.lookup(name)) != null)) { return sym; } if(this.parent) { return this.parent.find(name, publicOnly, typespace); } return null; }; SymbolScopeBuilder.prototype.findAmbient = function (name, publicOnly, typespace) { var sym = null; var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers; if(typespace) { ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers; } if(ambientTable && ((sym = ambientTable.lookup(name)) != null)) { return sym; } if(this.parent) { return this.parent.findAmbient(name, publicOnly, typespace); } return null; }; SymbolScopeBuilder.prototype.findLocal = function (name, publicOnly, typespace) { var sym = null; var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers; var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers; if(typespace) { table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers; ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers; } if(table) { if((sym = table.lookup(name)) != null) { if(sym) { return sym; } } } if(ambientTable) { if((sym = ambientTable.lookup(name)) != null) { if(sym) { return sym; } } } return null; }; SymbolScopeBuilder.prototype.enter = function (container, ast, symbol, errorReporter, insertAsPublic, typespace, ambient) { var table = null; if(ambient) { if(typespace) { table = (this.ambientEnclosedTypes == null) ? null : insertAsPublic ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.privateMembers; } else { table = (this.ambientValueMembers == null) ? null : insertAsPublic ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.privateMembers; } } else { if(typespace) { table = (this.enclosedTypes == null) ? null : insertAsPublic ? this.enclosedTypes.publicMembers : this.enclosedTypes.privateMembers; } else { table = (this.valueMembers == null) ? null : insertAsPublic ? this.valueMembers.publicMembers : this.valueMembers.privateMembers; } } if(table) { if(!table.add(symbol.name, symbol)) { errorReporter.duplicateIdentifier(ast, symbol.name); } } else { TypeScript.CompilerDiagnostics.Alert("YYYYY"); } symbol.container = container; }; SymbolScopeBuilder.prototype.getTable = function () { return this.valueMembers.allMembers; }; return SymbolScopeBuilder; })(SymbolScope); TypeScript.SymbolScopeBuilder = SymbolScopeBuilder; var FilteredSymbolScope = (function (_super) { __extends(FilteredSymbolScope, _super); function FilteredSymbolScope(scope, container, filter) { _super.call(this, container); this.scope = scope; this.filter = filter; } FilteredSymbolScope.prototype.print = function (outfile) { this.scope.print(outfile); }; FilteredSymbolScope.prototype.find = function (name, publicOnly, typespace) { this.filter.reset(); return this.scope.search(this.filter, name, publicOnly, typespace); }; FilteredSymbolScope.prototype.findLocal = function (name, publicOnly, typespace) { return this.scope.findLocal(name, publicOnly, typespace); }; return FilteredSymbolScope; })(SymbolScope); TypeScript.FilteredSymbolScope = FilteredSymbolScope; var FilteredSymbolScopeBuilder = (function (_super) { __extends(FilteredSymbolScopeBuilder, _super); function FilteredSymbolScopeBuilder(valueMembers, parent, container, filter) { _super.call(this, valueMembers, null, null, null, parent, container); this.filter = filter; } FilteredSymbolScopeBuilder.prototype.findLocal = function (name, publicOnly, typespace) { var sym = _super.prototype.findLocal.call(this, name, publicOnly, typespace); if(sym) { if(!this.filter(sym)) { return null; } } return sym; }; FilteredSymbolScopeBuilder.prototype.search = function (filter, name, publicOnly, typespace) { throw new Error("please implement"); }; FilteredSymbolScopeBuilder.prototype.find = function (name, publicOnly, typespace) { var sym = _super.prototype.findLocal.call(this, name, publicOnly, typespace); if(sym) { if(!this.filter(sym)) { return null; } } return _super.prototype.find.call(this, name, publicOnly, typespace); }; return FilteredSymbolScopeBuilder; })(SymbolScopeBuilder); TypeScript.FilteredSymbolScopeBuilder = FilteredSymbolScopeBuilder; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { (function (TokenID) { TokenID._map = []; TokenID._map[0] = "Any"; TokenID.Any = 0; TokenID._map[1] = "Bool"; TokenID.Bool = 1; TokenID._map[2] = "Break"; TokenID.Break = 2; TokenID._map[3] = "Case"; TokenID.Case = 3; TokenID._map[4] = "Catch"; TokenID.Catch = 4; TokenID._map[5] = "Class"; TokenID.Class = 5; TokenID._map[6] = "Const"; TokenID.Const = 6; TokenID._map[7] = "Continue"; TokenID.Continue = 7; TokenID._map[8] = "Debugger"; TokenID.Debugger = 8; TokenID._map[9] = "Default"; TokenID.Default = 9; TokenID._map[10] = "Delete"; TokenID.Delete = 10; TokenID._map[11] = "Do"; TokenID.Do = 11; TokenID._map[12] = "Else"; TokenID.Else = 12; TokenID._map[13] = "Enum"; TokenID.Enum = 13; TokenID._map[14] = "Export"; TokenID.Export = 14; TokenID._map[15] = "Extends"; TokenID.Extends = 15; TokenID._map[16] = "Declare"; TokenID.Declare = 16; TokenID._map[17] = "False"; TokenID.False = 17; TokenID._map[18] = "Finally"; TokenID.Finally = 18; TokenID._map[19] = "For"; TokenID.For = 19; TokenID._map[20] = "Function"; TokenID.Function = 20; TokenID._map[21] = "Constructor"; TokenID.Constructor = 21; TokenID._map[22] = "Get"; TokenID.Get = 22; TokenID._map[23] = "If"; TokenID.If = 23; TokenID._map[24] = "Implements"; TokenID.Implements = 24; TokenID._map[25] = "Import"; TokenID.Import = 25; TokenID._map[26] = "In"; TokenID.In = 26; TokenID._map[27] = "InstanceOf"; TokenID.InstanceOf = 27; TokenID._map[28] = "Interface"; TokenID.Interface = 28; TokenID._map[29] = "Let"; TokenID.Let = 29; TokenID._map[30] = "Module"; TokenID.Module = 30; TokenID._map[31] = "New"; TokenID.New = 31; TokenID._map[32] = "Number"; TokenID.Number = 32; TokenID._map[33] = "Null"; TokenID.Null = 33; TokenID._map[34] = "Package"; TokenID.Package = 34; TokenID._map[35] = "Private"; TokenID.Private = 35; TokenID._map[36] = "Protected"; TokenID.Protected = 36; TokenID._map[37] = "Public"; TokenID.Public = 37; TokenID._map[38] = "Return"; TokenID.Return = 38; TokenID._map[39] = "Set"; TokenID.Set = 39; TokenID._map[40] = "Static"; TokenID.Static = 40; TokenID._map[41] = "String"; TokenID.String = 41; TokenID._map[42] = "Super"; TokenID.Super = 42; TokenID._map[43] = "Switch"; TokenID.Switch = 43; TokenID._map[44] = "This"; TokenID.This = 44; TokenID._map[45] = "Throw"; TokenID.Throw = 45; TokenID._map[46] = "True"; TokenID.True = 46; TokenID._map[47] = "Try"; TokenID.Try = 47; TokenID._map[48] = "TypeOf"; TokenID.TypeOf = 48; TokenID._map[49] = "Var"; TokenID.Var = 49; TokenID._map[50] = "Void"; TokenID.Void = 50; TokenID._map[51] = "With"; TokenID.With = 51; TokenID._map[52] = "While"; TokenID.While = 52; TokenID._map[53] = "Yield"; TokenID.Yield = 53; TokenID._map[54] = "Semicolon"; TokenID.Semicolon = 54; TokenID._map[55] = "OpenParen"; TokenID.OpenParen = 55; TokenID._map[56] = "CloseParen"; TokenID.CloseParen = 56; TokenID._map[57] = "OpenBracket"; TokenID.OpenBracket = 57; TokenID._map[58] = "CloseBracket"; TokenID.CloseBracket = 58; TokenID._map[59] = "OpenBrace"; TokenID.OpenBrace = 59; TokenID._map[60] = "CloseBrace"; TokenID.CloseBrace = 60; TokenID._map[61] = "Comma"; TokenID.Comma = 61; TokenID._map[62] = "Equals"; TokenID.Equals = 62; TokenID._map[63] = "PlusEquals"; TokenID.PlusEquals = 63; TokenID._map[64] = "MinusEquals"; TokenID.MinusEquals = 64; TokenID._map[65] = "AsteriskEquals"; TokenID.AsteriskEquals = 65; TokenID._map[66] = "SlashEquals"; TokenID.SlashEquals = 66; TokenID._map[67] = "PercentEquals"; TokenID.PercentEquals = 67; TokenID._map[68] = "AmpersandEquals"; TokenID.AmpersandEquals = 68; TokenID._map[69] = "CaretEquals"; TokenID.CaretEquals = 69; TokenID._map[70] = "BarEquals"; TokenID.BarEquals = 70; TokenID._map[71] = "LessThanLessThanEquals"; TokenID.LessThanLessThanEquals = 71; TokenID._map[72] = "GreaterThanGreaterThanEquals"; TokenID.GreaterThanGreaterThanEquals = 72; TokenID._map[73] = "GreaterThanGreaterThanGreaterThanEquals"; TokenID.GreaterThanGreaterThanGreaterThanEquals = 73; TokenID._map[74] = "Question"; TokenID.Question = 74; TokenID._map[75] = "Colon"; TokenID.Colon = 75; TokenID._map[76] = "BarBar"; TokenID.BarBar = 76; TokenID._map[77] = "AmpersandAmpersand"; TokenID.AmpersandAmpersand = 77; TokenID._map[78] = "Bar"; TokenID.Bar = 78; TokenID._map[79] = "Caret"; TokenID.Caret = 79; TokenID._map[80] = "And"; TokenID.And = 80; TokenID._map[81] = "EqualsEquals"; TokenID.EqualsEquals = 81; TokenID._map[82] = "ExclamationEquals"; TokenID.ExclamationEquals = 82; TokenID._map[83] = "EqualsEqualsEquals"; TokenID.EqualsEqualsEquals = 83; TokenID._map[84] = "ExclamationEqualsEquals"; TokenID.ExclamationEqualsEquals = 84; TokenID._map[85] = "LessThan"; TokenID.LessThan = 85; TokenID._map[86] = "LessThanEquals"; TokenID.LessThanEquals = 86; TokenID._map[87] = "GreaterThan"; TokenID.GreaterThan = 87; TokenID._map[88] = "GreaterThanEquals"; TokenID.GreaterThanEquals = 88; TokenID._map[89] = "LessThanLessThan"; TokenID.LessThanLessThan = 89; TokenID._map[90] = "GreaterThanGreaterThan"; TokenID.GreaterThanGreaterThan = 90; TokenID._map[91] = "GreaterThanGreaterThanGreaterThan"; TokenID.GreaterThanGreaterThanGreaterThan = 91; TokenID._map[92] = "Plus"; TokenID.Plus = 92; TokenID._map[93] = "Minus"; TokenID.Minus = 93; TokenID._map[94] = "Asterisk"; TokenID.Asterisk = 94; TokenID._map[95] = "Slash"; TokenID.Slash = 95; TokenID._map[96] = "Percent"; TokenID.Percent = 96; TokenID._map[97] = "Tilde"; TokenID.Tilde = 97; TokenID._map[98] = "Exclamation"; TokenID.Exclamation = 98; TokenID._map[99] = "PlusPlus"; TokenID.PlusPlus = 99; TokenID._map[100] = "MinusMinus"; TokenID.MinusMinus = 100; TokenID._map[101] = "Dot"; TokenID.Dot = 101; TokenID._map[102] = "DotDotDot"; TokenID.DotDotDot = 102; TokenID._map[103] = "Error"; TokenID.Error = 103; TokenID._map[104] = "EndOfFile"; TokenID.EndOfFile = 104; TokenID._map[105] = "EqualsGreaterThan"; TokenID.EqualsGreaterThan = 105; TokenID._map[106] = "Identifier"; TokenID.Identifier = 106; TokenID._map[107] = "StringLiteral"; TokenID.StringLiteral = 107; TokenID._map[108] = "RegularExpressionLiteral"; TokenID.RegularExpressionLiteral = 108; TokenID._map[109] = "NumberLiteral"; TokenID.NumberLiteral = 109; TokenID._map[110] = "Whitespace"; TokenID.Whitespace = 110; TokenID._map[111] = "Comment"; TokenID.Comment = 111; TokenID._map[112] = "Lim"; TokenID.Lim = 112; TokenID.LimFixed = TokenID.EqualsGreaterThan; TokenID.LimKeyword = TokenID.Yield; })(TypeScript.TokenID || (TypeScript.TokenID = {})); var TokenID = TypeScript.TokenID; TypeScript.tokenTable = new Array(); TypeScript.nodeTypeTable = new Array(); TypeScript.nodeTypeToTokTable = new Array(); TypeScript.noRegexTable = new Array(); TypeScript.noRegexTable[TokenID.Identifier] = true; TypeScript.noRegexTable[TokenID.StringLiteral] = true; TypeScript.noRegexTable[TokenID.NumberLiteral] = true; TypeScript.noRegexTable[TokenID.RegularExpressionLiteral] = true; TypeScript.noRegexTable[TokenID.This] = true; TypeScript.noRegexTable[TokenID.PlusPlus] = true; TypeScript.noRegexTable[TokenID.MinusMinus] = true; TypeScript.noRegexTable[TokenID.CloseParen] = true; TypeScript.noRegexTable[TokenID.CloseBracket] = true; TypeScript.noRegexTable[TokenID.CloseBrace] = true; TypeScript.noRegexTable[TokenID.True] = true; TypeScript.noRegexTable[TokenID.False] = true; (function (OperatorPrecedence) { OperatorPrecedence._map = []; OperatorPrecedence._map[0] = "None"; OperatorPrecedence.None = 0; OperatorPrecedence._map[1] = "Comma"; OperatorPrecedence.Comma = 1; OperatorPrecedence._map[2] = "Assignment"; OperatorPrecedence.Assignment = 2; OperatorPrecedence._map[3] = "Conditional"; OperatorPrecedence.Conditional = 3; OperatorPrecedence._map[4] = "LogicalOr"; OperatorPrecedence.LogicalOr = 4; OperatorPrecedence._map[5] = "LogicalAnd"; OperatorPrecedence.LogicalAnd = 5; OperatorPrecedence._map[6] = "BitwiseOr"; OperatorPrecedence.BitwiseOr = 6; OperatorPrecedence._map[7] = "BitwiseExclusiveOr"; OperatorPrecedence.BitwiseExclusiveOr = 7; OperatorPrecedence._map[8] = "BitwiseAnd"; OperatorPrecedence.BitwiseAnd = 8; OperatorPrecedence._map[9] = "Equality"; OperatorPrecedence.Equality = 9; OperatorPrecedence._map[10] = "Relational"; OperatorPrecedence.Relational = 10; OperatorPrecedence._map[11] = "Shift"; OperatorPrecedence.Shift = 11; OperatorPrecedence._map[12] = "Additive"; OperatorPrecedence.Additive = 12; OperatorPrecedence._map[13] = "Multiplicative"; OperatorPrecedence.Multiplicative = 13; OperatorPrecedence._map[14] = "Unary"; OperatorPrecedence.Unary = 14; OperatorPrecedence._map[15] = "Lim"; OperatorPrecedence.Lim = 15; })(TypeScript.OperatorPrecedence || (TypeScript.OperatorPrecedence = {})); var OperatorPrecedence = TypeScript.OperatorPrecedence; (function (Reservation) { Reservation._map = []; Reservation.None = 0; Reservation.Javascript = 1; Reservation.JavascriptFuture = 2; Reservation.TypeScript = 4; Reservation.JavascriptFutureStrict = 8; Reservation.TypeScriptAndJS = Reservation.Javascript | Reservation.TypeScript; Reservation.TypeScriptAndJSFuture = Reservation.JavascriptFuture | Reservation.TypeScript; Reservation.TypeScriptAndJSFutureStrict = Reservation.JavascriptFutureStrict | Reservation.TypeScript; })(TypeScript.Reservation || (TypeScript.Reservation = {})); var Reservation = TypeScript.Reservation; var TokenInfo = (function () { function TokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers) { this.tokenId = tokenId; this.reservation = reservation; this.binopPrecedence = binopPrecedence; this.binopNodeType = binopNodeType; this.unopPrecedence = unopPrecedence; this.unopNodeType = unopNodeType; this.text = text; this.ers = ers; } return TokenInfo; })(); TypeScript.TokenInfo = TokenInfo; function setTokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers) { if(tokenId !== undefined) { TypeScript.tokenTable[tokenId] = new TokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers); if(binopNodeType != TypeScript.NodeType.None) { TypeScript.nodeTypeTable[binopNodeType] = text; TypeScript.nodeTypeToTokTable[binopNodeType] = tokenId; } if(unopNodeType != TypeScript.NodeType.None) { TypeScript.nodeTypeTable[unopNodeType] = text; } } } setTokenInfo(TokenID.Any, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "any", TypeScript.ErrorRecoverySet.PrimType); setTokenInfo(TokenID.Bool, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "bool", TypeScript.ErrorRecoverySet.PrimType); setTokenInfo(TokenID.Break, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "break", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.Case, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "case", TypeScript.ErrorRecoverySet.SCase); setTokenInfo(TokenID.Catch, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "catch", TypeScript.ErrorRecoverySet.Catch); setTokenInfo(TokenID.Class, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "class", TypeScript.ErrorRecoverySet.TypeScriptS); setTokenInfo(TokenID.Const, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "const", TypeScript.ErrorRecoverySet.Var); setTokenInfo(TokenID.Continue, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "continue", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.Debugger, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.Debugger, "debugger", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.Default, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "default", TypeScript.ErrorRecoverySet.SCase); setTokenInfo(TokenID.Delete, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Delete, "delete", TypeScript.ErrorRecoverySet.Prefix); setTokenInfo(TokenID.Do, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "do", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.Else, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "else", TypeScript.ErrorRecoverySet.Else); setTokenInfo(TokenID.Enum, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "enum", TypeScript.ErrorRecoverySet.TypeScriptS); setTokenInfo(TokenID.Export, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "export", TypeScript.ErrorRecoverySet.TypeScriptS); setTokenInfo(TokenID.Extends, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "extends", TypeScript.ErrorRecoverySet.None); setTokenInfo(TokenID.Declare, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "declare", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.False, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "false", TypeScript.ErrorRecoverySet.RLit); setTokenInfo(TokenID.Finally, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "finally", TypeScript.ErrorRecoverySet.Catch); setTokenInfo(TokenID.For, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "for", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.Function, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "function", TypeScript.ErrorRecoverySet.Func); setTokenInfo(TokenID.Constructor, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "constructor", TypeScript.ErrorRecoverySet.Func); setTokenInfo(TokenID.Get, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "get", TypeScript.ErrorRecoverySet.Func); setTokenInfo(TokenID.Set, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "set", TypeScript.ErrorRecoverySet.Func); setTokenInfo(TokenID.If, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "if", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.Implements, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "implements", TypeScript.ErrorRecoverySet.None); setTokenInfo(TokenID.Import, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "import", TypeScript.ErrorRecoverySet.TypeScriptS); setTokenInfo(TokenID.In, Reservation.TypeScriptAndJS, OperatorPrecedence.Relational, TypeScript.NodeType.In, OperatorPrecedence.None, TypeScript.NodeType.None, "in", TypeScript.ErrorRecoverySet.None); setTokenInfo(TokenID.InstanceOf, Reservation.TypeScriptAndJS, OperatorPrecedence.Relational, TypeScript.NodeType.InstOf, OperatorPrecedence.None, TypeScript.NodeType.None, "instanceof", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.Interface, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "interface", TypeScript.ErrorRecoverySet.TypeScriptS); setTokenInfo(TokenID.Let, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "let", TypeScript.ErrorRecoverySet.None); setTokenInfo(TokenID.Module, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "module", TypeScript.ErrorRecoverySet.TypeScriptS); setTokenInfo(TokenID.New, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "new", TypeScript.ErrorRecoverySet.PreOp); setTokenInfo(TokenID.Number, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "number", TypeScript.ErrorRecoverySet.PrimType); setTokenInfo(TokenID.Null, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "null", TypeScript.ErrorRecoverySet.RLit); setTokenInfo(TokenID.Package, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "package", TypeScript.ErrorRecoverySet.None); setTokenInfo(TokenID.Private, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "private", TypeScript.ErrorRecoverySet.TypeScriptS); setTokenInfo(TokenID.Protected, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "protected", TypeScript.ErrorRecoverySet.None); setTokenInfo(TokenID.Public, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "public", TypeScript.ErrorRecoverySet.TypeScriptS); setTokenInfo(TokenID.Return, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "return", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.Static, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "static", TypeScript.ErrorRecoverySet.None); setTokenInfo(TokenID.String, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "string", TypeScript.ErrorRecoverySet.PrimType); setTokenInfo(TokenID.Super, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "super", TypeScript.ErrorRecoverySet.RLit); setTokenInfo(TokenID.Switch, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "switch", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.This, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "this", TypeScript.ErrorRecoverySet.RLit); setTokenInfo(TokenID.Throw, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "throw", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.True, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "true", TypeScript.ErrorRecoverySet.RLit); setTokenInfo(TokenID.Try, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "try", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.TypeOf, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Typeof, "typeof", TypeScript.ErrorRecoverySet.Prefix); setTokenInfo(TokenID.Var, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "var", TypeScript.ErrorRecoverySet.Var); setTokenInfo(TokenID.Void, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Void, "void", TypeScript.ErrorRecoverySet.Prefix); setTokenInfo(TokenID.With, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.With, "with", TypeScript.ErrorRecoverySet.Stmt); setTokenInfo(TokenID.While, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "while", TypeScript.ErrorRecoverySet.While); setTokenInfo(TokenID.Yield, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "yield", TypeScript.ErrorRecoverySet.None); setTokenInfo(TokenID.Identifier, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "identifier", TypeScript.ErrorRecoverySet.ID); setTokenInfo(TokenID.NumberLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "numberLiteral", TypeScript.ErrorRecoverySet.Literal); setTokenInfo(TokenID.RegularExpressionLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "regex", TypeScript.ErrorRecoverySet.RegExp); setTokenInfo(TokenID.StringLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "qstring", TypeScript.ErrorRecoverySet.Literal); setTokenInfo(TokenID.Semicolon, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ";", TypeScript.ErrorRecoverySet.SColon); setTokenInfo(TokenID.CloseParen, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ")", TypeScript.ErrorRecoverySet.RParen); setTokenInfo(TokenID.CloseBracket, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "]", TypeScript.ErrorRecoverySet.RBrack); setTokenInfo(TokenID.OpenBrace, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "{", TypeScript.ErrorRecoverySet.LCurly); setTokenInfo(TokenID.CloseBrace, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "}", TypeScript.ErrorRecoverySet.RCurly); setTokenInfo(TokenID.DotDotDot, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "...", TypeScript.ErrorRecoverySet.None); setTokenInfo(TokenID.Comma, Reservation.None, OperatorPrecedence.Comma, TypeScript.NodeType.Comma, OperatorPrecedence.None, TypeScript.NodeType.None, ",", TypeScript.ErrorRecoverySet.Comma); setTokenInfo(TokenID.Equals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.Asg, OperatorPrecedence.None, TypeScript.NodeType.None, "=", TypeScript.ErrorRecoverySet.Asg); setTokenInfo(TokenID.PlusEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgAdd, OperatorPrecedence.None, TypeScript.NodeType.None, "+=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.MinusEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgSub, OperatorPrecedence.None, TypeScript.NodeType.None, "-=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.AsteriskEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgMul, OperatorPrecedence.None, TypeScript.NodeType.None, "*=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.SlashEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgDiv, OperatorPrecedence.None, TypeScript.NodeType.None, "/=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.PercentEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgMod, OperatorPrecedence.None, TypeScript.NodeType.None, "%=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.AmpersandEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgAnd, OperatorPrecedence.None, TypeScript.NodeType.None, "&=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.CaretEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgXor, OperatorPrecedence.None, TypeScript.NodeType.None, "^=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.BarEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgOr, OperatorPrecedence.None, TypeScript.NodeType.None, "|=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.LessThanLessThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgLsh, OperatorPrecedence.None, TypeScript.NodeType.None, "<<=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.GreaterThanGreaterThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgRsh, OperatorPrecedence.None, TypeScript.NodeType.None, ">>=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.GreaterThanGreaterThanGreaterThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgRs2, OperatorPrecedence.None, TypeScript.NodeType.None, ">>>=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.Question, Reservation.None, OperatorPrecedence.Conditional, TypeScript.NodeType.ConditionalExpression, OperatorPrecedence.None, TypeScript.NodeType.None, "?", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.Colon, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ":", TypeScript.ErrorRecoverySet.Colon); setTokenInfo(TokenID.BarBar, Reservation.None, OperatorPrecedence.LogicalOr, TypeScript.NodeType.LogOr, OperatorPrecedence.None, TypeScript.NodeType.None, "||", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.AmpersandAmpersand, Reservation.None, OperatorPrecedence.LogicalAnd, TypeScript.NodeType.LogAnd, OperatorPrecedence.None, TypeScript.NodeType.None, "&&", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.Bar, Reservation.None, OperatorPrecedence.BitwiseOr, TypeScript.NodeType.Or, OperatorPrecedence.None, TypeScript.NodeType.None, "|", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.Caret, Reservation.None, OperatorPrecedence.BitwiseExclusiveOr, TypeScript.NodeType.Xor, OperatorPrecedence.None, TypeScript.NodeType.None, "^", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.And, Reservation.None, OperatorPrecedence.BitwiseAnd, TypeScript.NodeType.And, OperatorPrecedence.None, TypeScript.NodeType.None, "&", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.EqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Eq, OperatorPrecedence.None, TypeScript.NodeType.None, "==", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.ExclamationEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Ne, OperatorPrecedence.None, TypeScript.NodeType.None, "!=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.EqualsEqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Eqv, OperatorPrecedence.None, TypeScript.NodeType.None, "===", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.ExclamationEqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.NEqv, OperatorPrecedence.None, TypeScript.NodeType.None, "!==", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.LessThan, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Lt, OperatorPrecedence.None, TypeScript.NodeType.None, "<", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.LessThanEquals, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Le, OperatorPrecedence.None, TypeScript.NodeType.None, "<=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.GreaterThan, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Gt, OperatorPrecedence.None, TypeScript.NodeType.None, ">", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.GreaterThanEquals, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Ge, OperatorPrecedence.None, TypeScript.NodeType.None, ">=", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.LessThanLessThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Lsh, OperatorPrecedence.None, TypeScript.NodeType.None, "<<", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.GreaterThanGreaterThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Rsh, OperatorPrecedence.None, TypeScript.NodeType.None, ">>", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.GreaterThanGreaterThanGreaterThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Rs2, OperatorPrecedence.None, TypeScript.NodeType.None, ">>>", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.Plus, Reservation.None, OperatorPrecedence.Additive, TypeScript.NodeType.Add, OperatorPrecedence.Unary, TypeScript.NodeType.Pos, "+", TypeScript.ErrorRecoverySet.AddOp); setTokenInfo(TokenID.Minus, Reservation.None, OperatorPrecedence.Additive, TypeScript.NodeType.Sub, OperatorPrecedence.Unary, TypeScript.NodeType.Neg, "-", TypeScript.ErrorRecoverySet.AddOp); setTokenInfo(TokenID.Asterisk, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Mul, OperatorPrecedence.None, TypeScript.NodeType.None, "*", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.Slash, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Div, OperatorPrecedence.None, TypeScript.NodeType.None, "/", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.Percent, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Mod, OperatorPrecedence.None, TypeScript.NodeType.None, "%", TypeScript.ErrorRecoverySet.BinOp); setTokenInfo(TokenID.Tilde, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Not, "~", TypeScript.ErrorRecoverySet.PreOp); setTokenInfo(TokenID.Exclamation, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.LogNot, "!", TypeScript.ErrorRecoverySet.PreOp); setTokenInfo(TokenID.PlusPlus, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.IncPre, "++", TypeScript.ErrorRecoverySet.PreOp); setTokenInfo(TokenID.MinusMinus, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.DecPre, "--", TypeScript.ErrorRecoverySet.PreOp); setTokenInfo(TokenID.OpenParen, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "(", TypeScript.ErrorRecoverySet.LParen); setTokenInfo(TokenID.OpenBracket, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "[", TypeScript.ErrorRecoverySet.LBrack); setTokenInfo(TokenID.Dot, Reservation.None, OperatorPrecedence.Unary, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ".", TypeScript.ErrorRecoverySet.Dot); setTokenInfo(TokenID.EndOfFile, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "", TypeScript.ErrorRecoverySet.EOF); setTokenInfo(TokenID.EqualsGreaterThan, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "=>", TypeScript.ErrorRecoverySet.None); function lookupToken(tokenId) { return TypeScript.tokenTable[tokenId]; } TypeScript.lookupToken = lookupToken; (function (TokenClass) { TokenClass._map = []; TokenClass._map[0] = "Punctuation"; TokenClass.Punctuation = 0; TokenClass._map[1] = "Keyword"; TokenClass.Keyword = 1; TokenClass._map[2] = "Operator"; TokenClass.Operator = 2; TokenClass._map[3] = "Comment"; TokenClass.Comment = 3; TokenClass._map[4] = "Whitespace"; TokenClass.Whitespace = 4; TokenClass._map[5] = "Identifier"; TokenClass.Identifier = 5; TokenClass._map[6] = "NumberLiteral"; TokenClass.NumberLiteral = 6; TokenClass._map[7] = "StringLiteral"; TokenClass.StringLiteral = 7; TokenClass._map[8] = "RegExpLiteral"; TokenClass.RegExpLiteral = 8; })(TypeScript.TokenClass || (TypeScript.TokenClass = {})); var TokenClass = TypeScript.TokenClass; var SavedToken = (function () { function SavedToken(tok, minChar, limChar) { this.tok = tok; this.minChar = minChar; this.limChar = limChar; } return SavedToken; })(); TypeScript.SavedToken = SavedToken; var Token = (function () { function Token(tokenId) { this.tokenId = tokenId; } Token.prototype.toString = function () { return "token: " + this.tokenId + " " + this.getText() + " (" + (TokenID)._map[this.tokenId] + ")"; }; Token.prototype.print = function (line, outfile) { outfile.WriteLine(this.toString() + ",on line" + line); }; Token.prototype.getText = function () { return TypeScript.tokenTable[this.tokenId].text; }; Token.prototype.classification = function () { if(this.tokenId <= TokenID.LimKeyword) { return TokenClass.Keyword; } else { var tokenInfo = lookupToken(this.tokenId); if(tokenInfo != undefined) { if((tokenInfo.unopNodeType != TypeScript.NodeType.None) || (tokenInfo.binopNodeType != TypeScript.NodeType.None)) { return TokenClass.Operator; } } } return TokenClass.Punctuation; }; return Token; })(); TypeScript.Token = Token; var NumberLiteralToken = (function (_super) { __extends(NumberLiteralToken, _super); function NumberLiteralToken(value, hasEmptyFraction) { _super.call(this, TokenID.NumberLiteral); this.value = value; this.hasEmptyFraction = hasEmptyFraction; } NumberLiteralToken.prototype.getText = function () { return this.hasEmptyFraction ? this.value.toString() + ".0" : this.value.toString(); }; NumberLiteralToken.prototype.classification = function () { return TokenClass.NumberLiteral; }; return NumberLiteralToken; })(Token); TypeScript.NumberLiteralToken = NumberLiteralToken; var StringLiteralToken = (function (_super) { __extends(StringLiteralToken, _super); function StringLiteralToken(value) { _super.call(this, TokenID.StringLiteral); this.value = value; } StringLiteralToken.prototype.getText = function () { return this.value; }; StringLiteralToken.prototype.classification = function () { return TokenClass.StringLiteral; }; return StringLiteralToken; })(Token); TypeScript.StringLiteralToken = StringLiteralToken; var IdentifierToken = (function (_super) { __extends(IdentifierToken, _super); function IdentifierToken(value, hasEscapeSequence) { _super.call(this, TokenID.Identifier); this.value = value; this.hasEscapeSequence = hasEscapeSequence; } IdentifierToken.prototype.getText = function () { return this.value; }; IdentifierToken.prototype.classification = function () { return TokenClass.Identifier; }; return IdentifierToken; })(Token); TypeScript.IdentifierToken = IdentifierToken; var WhitespaceToken = (function (_super) { __extends(WhitespaceToken, _super); function WhitespaceToken(tokenId, value) { _super.call(this, tokenId); this.value = value; } WhitespaceToken.prototype.getText = function () { return this.value; }; WhitespaceToken.prototype.classification = function () { return TokenClass.Whitespace; }; return WhitespaceToken; })(Token); TypeScript.WhitespaceToken = WhitespaceToken; var CommentToken = (function (_super) { __extends(CommentToken, _super); function CommentToken(tokenID, value, isBlock, startPos, line, endsLine) { _super.call(this, tokenID); this.value = value; this.isBlock = isBlock; this.startPos = startPos; this.line = line; this.endsLine = endsLine; } CommentToken.prototype.getText = function () { return this.value; }; CommentToken.prototype.classification = function () { return TokenClass.Comment; }; return CommentToken; })(Token); TypeScript.CommentToken = CommentToken; var RegularExpressionLiteralToken = (function (_super) { __extends(RegularExpressionLiteralToken, _super); function RegularExpressionLiteralToken(regex) { _super.call(this, TokenID.RegularExpressionLiteral); this.regex = regex; } RegularExpressionLiteralToken.prototype.getText = function () { return this.regex.toString(); }; RegularExpressionLiteralToken.prototype.classification = function () { return TokenClass.RegExpLiteral; }; return RegularExpressionLiteralToken; })(Token); TypeScript.RegularExpressionLiteralToken = RegularExpressionLiteralToken; TypeScript.staticTokens = new Array(); function initializeStaticTokens() { for(var i = 0; i <= TokenID.LimFixed; i++) { TypeScript.staticTokens[i] = new Token(i); } } TypeScript.initializeStaticTokens = initializeStaticTokens; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var ArrayCache = (function () { function ArrayCache() { this.arrayBase = null; } ArrayCache.prototype.specialize = function (arrInstType, checker) { if(this.arrayBase == null) { this.arrayBase = arrInstType.specializeType(checker.wildElm.type, this.arrayType.elementType, checker, true); } return this.arrayBase; }; return ArrayCache; })(); TypeScript.ArrayCache = ArrayCache; var TypeComparisonInfo = (function () { function TypeComparisonInfo() { this.onlyCaptureFirstError = false; this.flags = TypeScript.TypeRelationshipFlags.SuccessfulComparison; this.message = ""; } TypeComparisonInfo.prototype.addMessageToFront = function (message) { if(!this.onlyCaptureFirstError) { this.message = this.message ? message + ":\n\t" + this.message : message; } else { this.setMessage(message); } }; TypeComparisonInfo.prototype.setMessage = function (message) { this.message = message; }; return TypeComparisonInfo; })(); TypeScript.TypeComparisonInfo = TypeComparisonInfo; (function (TypeCheckCollectionMode) { TypeCheckCollectionMode._map = []; TypeCheckCollectionMode._map[0] = "Resident"; TypeCheckCollectionMode.Resident = 0; TypeCheckCollectionMode._map[1] = "Transient"; TypeCheckCollectionMode.Transient = 1; })(TypeScript.TypeCheckCollectionMode || (TypeScript.TypeCheckCollectionMode = {})); var TypeCheckCollectionMode = TypeScript.TypeCheckCollectionMode; var PersistentGlobalTypeState = (function () { function PersistentGlobalTypeState(errorReporter) { this.errorReporter = errorReporter; this.importedGlobalsTable = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); this.importedGlobalsTypeTable = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); this.globals = null; this.globalTypes = null; this.ambientGlobals = null; this.ambientGlobalTypes = null; this.residentGlobalValues = new TypeScript.StringHashTable(); this.residentGlobalTypes = new TypeScript.StringHashTable(); this.residentGlobalAmbientValues = new TypeScript.StringHashTable(); this.residentGlobalAmbientTypes = new TypeScript.StringHashTable(); this.residentTypeCheck = true; this.mod = null; this.gloMod = null; this.wildElm = null; this.importedGlobals = new TypeScript.SymbolScopeBuilder(null, this.importedGlobalsTable, null, this.importedGlobalsTypeTable, null, null); this.dualGlobalValues = new TypeScript.DualStringHashTable(this.residentGlobalValues, new TypeScript.StringHashTable()); this.dualGlobalTypes = new TypeScript.DualStringHashTable(this.residentGlobalTypes, new TypeScript.StringHashTable()); this.dualAmbientGlobalValues = new TypeScript.DualStringHashTable(this.residentGlobalAmbientValues, new TypeScript.StringHashTable()); this.dualAmbientGlobalTypes = new TypeScript.DualStringHashTable(this.residentGlobalAmbientTypes, new TypeScript.StringHashTable()); var dualGlobalScopedMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(this.dualGlobalValues, new TypeScript.StringHashTable())); var dualGlobalScopedAmbientMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(this.dualAmbientGlobalValues, new TypeScript.StringHashTable())); var dualGlobalScopedEnclosedTypes = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(this.dualGlobalTypes, new TypeScript.StringHashTable())); var dualGlobalScopedAmbientEnclosedTypes = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(this.dualAmbientGlobalTypes, new TypeScript.StringHashTable())); this.globalScope = new TypeScript.SymbolScopeBuilder(dualGlobalScopedMembers, dualGlobalScopedAmbientMembers, dualGlobalScopedEnclosedTypes, dualGlobalScopedAmbientEnclosedTypes, this.importedGlobals, null); this.voidType = this.enterPrimitive(TypeScript.Primitive.Void, "void"); this.booleanType = this.enterPrimitive(TypeScript.Primitive.Boolean, "bool"); this.doubleType = this.enterPrimitive(TypeScript.Primitive.Double, "number"); this.importedGlobals.ambientEnclosedTypes.addPublicMember("number", this.doubleType.symbol); this.stringType = this.enterPrimitive(TypeScript.Primitive.String, "string"); this.anyType = this.enterPrimitive(TypeScript.Primitive.Any, "any"); this.nullType = this.enterPrimitive(TypeScript.Primitive.Null, "null"); this.undefinedType = this.enterPrimitive(TypeScript.Primitive.Undefined, "undefined"); this.setCollectionMode(TypeCheckCollectionMode.Resident); this.wildElm = new TypeScript.TypeSymbol("_element", -1, 0, -1, new TypeScript.Type()); this.importedGlobalsTypeTable.addPublicMember(this.wildElm.name, this.wildElm); this.mod = new TypeScript.ModuleType(dualGlobalScopedEnclosedTypes, dualGlobalScopedAmbientEnclosedTypes); this.mod.members = dualGlobalScopedMembers; this.mod.ambientMembers = dualGlobalScopedAmbientMembers; this.mod.containedScope = this.globalScope; this.gloMod = new TypeScript.TypeSymbol(TypeScript.globalId, -1, 0, -1, this.mod); this.mod.members.addPublicMember(this.gloMod.name, this.gloMod); this.defineGlobalValue("undefined", this.undefinedType); } PersistentGlobalTypeState.prototype.enterPrimitive = function (flags, name) { var primitive = new TypeScript.Type(); primitive.primitiveTypeClass = flags; var symbol = new TypeScript.TypeSymbol(name, -1, name.length, -1, primitive); symbol.typeCheckStatus = TypeScript.TypeCheckStatus.Finished; primitive.symbol = symbol; this.importedGlobals.enter(null, null, symbol, this.errorReporter, true, true, true); return primitive; }; PersistentGlobalTypeState.prototype.setCollectionMode = function (mode) { this.residentTypeCheck = this.dualGlobalValues.insertPrimary = this.dualGlobalTypes.insertPrimary = this.dualAmbientGlobalValues.insertPrimary = this.dualAmbientGlobalTypes.insertPrimary = mode == TypeCheckCollectionMode.Resident; }; PersistentGlobalTypeState.prototype.refreshPersistentState = function () { this.globals = new TypeScript.StringHashTable(); this.globalTypes = new TypeScript.StringHashTable(); this.ambientGlobals = new TypeScript.StringHashTable(); this.ambientGlobalTypes = new TypeScript.StringHashTable(); this.globalTypes.add(this.voidType.symbol.name, this.voidType.symbol); this.globalTypes.add(this.booleanType.symbol.name, this.booleanType.symbol); this.globalTypes.add(this.doubleType.symbol.name, this.doubleType.symbol); this.globalTypes.add("number", this.doubleType.symbol); this.globalTypes.add(this.stringType.symbol.name, this.stringType.symbol); this.globalTypes.add(this.anyType.symbol.name, this.anyType.symbol); this.globalTypes.add(this.nullType.symbol.name, this.nullType.symbol); this.globalTypes.add(this.undefinedType.symbol.name, this.undefinedType.symbol); this.dualGlobalValues.secondaryTable = this.globals; this.dualGlobalTypes.secondaryTable = this.globalTypes; this.dualAmbientGlobalValues.secondaryTable = this.ambientGlobals; this.dualAmbientGlobalTypes.secondaryTable = this.ambientGlobalTypes; }; PersistentGlobalTypeState.prototype.defineGlobalValue = function (name, type) { var valueLocation = new TypeScript.ValueLocation(); valueLocation.typeLink = new TypeScript.TypeLink(); var sym = new TypeScript.VariableSymbol(name, 0, -1, valueLocation); sym.setType(type); sym.typeCheckStatus = TypeScript.TypeCheckStatus.Finished; sym.container = this.gloMod; this.importedGlobalsTable.addPublicMember(name, sym); }; return PersistentGlobalTypeState; })(); TypeScript.PersistentGlobalTypeState = PersistentGlobalTypeState; var ContextualTypeContext = (function () { function ContextualTypeContext(contextualType, provisional, contextID) { this.contextualType = contextualType; this.provisional = provisional; this.contextID = contextID; this.targetSig = null; this.targetThis = null; this.targetAccessorType = null; } return ContextualTypeContext; })(); TypeScript.ContextualTypeContext = ContextualTypeContext; var ContextualTypingContextStack = (function () { function ContextualTypingContextStack(checker) { this.checker = checker; this.contextStack = []; this.hadProvisionalErrors = false; } ContextualTypingContextStack.contextID = TypeScript.TypeCheckStatus.Finished + 1; ContextualTypingContextStack.prototype.pushContextualType = function (type, provisional) { this.contextStack.push(new ContextualTypeContext(type, provisional, ContextualTypingContextStack.contextID++)); this.checker.errorReporter.pushToErrorSink = provisional; }; ContextualTypingContextStack.prototype.popContextualType = function () { var tc = this.contextStack.pop(); this.checker.errorReporter.pushToErrorSink = this.isProvisional(); this.hadProvisionalErrors = this.hadProvisionalErrors || (tc.provisional && (this.checker.errorReporter.getCapturedErrors().length)); this.checker.errorReporter.freeCapturedErrors(); return tc; }; ContextualTypingContextStack.prototype.getContextualType = function () { return (!this.contextStack.length ? null : this.contextStack[this.contextStack.length - 1]); }; ContextualTypingContextStack.prototype.getContextID = function () { return (!this.contextStack.length ? TypeScript.TypeCheckStatus.Finished : this.contextStack[this.contextStack.length - 1].contextID); }; ContextualTypingContextStack.prototype.isProvisional = function () { return (!this.contextStack.length ? false : this.contextStack[this.contextStack.length - 1].provisional); }; return ContextualTypingContextStack; })(); TypeScript.ContextualTypingContextStack = ContextualTypingContextStack; var TypeChecker = (function () { function TypeChecker(persistentState) { this.persistentState = persistentState; this.errorReporter = null; this.checkControlFlow = false; this.printControlFlowGraph = false; this.checkControlFlowUseDef = false; this.styleSettings = null; this.units = null; this.anon = "_anonymous"; this.locationInfo = null; this.typeFlow = null; this.currentCompareA = null; this.currentCompareB = null; this.currentModDecl = null; this.inBind = false; this.inWith = false; this.errorsOnWith = true; this.currentContextualTypeContext = null; this.resolvingBases = false; this.canCallDefinitionSignature = false; this.assignableCache = { }; this.subtypeCache = { }; this.identicalCache = { }; this.provisionalStartedTypecheckObjects = []; this.mustCaptureGlobalThis = false; this.voidType = this.persistentState.voidType; this.booleanType = this.persistentState.booleanType; this.numberType = this.persistentState.doubleType; this.stringType = this.persistentState.stringType; this.anyType = this.persistentState.anyType; this.nullType = this.persistentState.nullType; this.undefinedType = this.persistentState.undefinedType; this.globals = this.persistentState.dualGlobalValues; this.globalTypes = this.persistentState.dualGlobalTypes; this.ambientGlobals = this.persistentState.dualAmbientGlobalValues; this.ambientGlobalTypes = this.persistentState.dualAmbientGlobalTypes; this.gloModType = this.persistentState.mod; this.gloMod = this.persistentState.gloMod; this.wildElm = this.persistentState.wildElm; this.globalScope = this.persistentState.globalScope; this.typingContextStack = new ContextualTypingContextStack(this); } TypeChecker.prototype.setStyleOptions = function (style) { this.styleSettings = style; }; TypeChecker.prototype.setContextualType = function (type, provisional) { this.typingContextStack.pushContextualType(type, provisional); this.currentContextualTypeContext = this.typingContextStack.getContextualType(); }; TypeChecker.prototype.unsetContextualType = function () { var lastTC = this.typingContextStack.popContextualType(); this.currentContextualTypeContext = this.typingContextStack.getContextualType(); return lastTC; }; TypeChecker.prototype.hadProvisionalErrors = function () { return this.typingContextStack.hadProvisionalErrors; }; TypeChecker.prototype.resetProvisionalErrors = function () { if(!this.typingContextStack.getContextualType()) { this.typingContextStack.hadProvisionalErrors = false; } }; TypeChecker.prototype.typeCheckWithContextualType = function (contextType, provisional, condition, ast) { if(condition) { this.setContextualType(contextType, this.typingContextStack.isProvisional() || provisional); } this.typeFlow.typeCheck(ast); if(condition) { this.unsetContextualType(); } }; TypeChecker.prototype.resetTargetType = function () { this.currentContextualTypeContext = this.typingContextStack.getContextualType(); }; TypeChecker.prototype.killCurrentContextualType = function () { this.currentContextualTypeContext = null; this.errorReporter.pushToErrorSink = false; }; TypeChecker.prototype.hasTargetType = function () { return this.currentContextualTypeContext && this.currentContextualTypeContext.contextualType; }; TypeChecker.prototype.getTargetTypeContext = function () { return this.currentContextualTypeContext; }; TypeChecker.prototype.inProvisionalTypecheckMode = function () { return this.typingContextStack.isProvisional(); }; TypeChecker.prototype.getTypeCheckFinishedStatus = function () { if(this.inProvisionalTypecheckMode()) { return this.typingContextStack.getContextID(); } return TypeScript.TypeCheckStatus.Finished; }; TypeChecker.prototype.typeStatusIsFinished = function (status) { return status == TypeScript.TypeCheckStatus.Finished || (this.inProvisionalTypecheckMode() && status == this.typingContextStack.getContextID()); }; TypeChecker.prototype.addStartedPTO = function (pto) { if(this.inProvisionalTypecheckMode()) { this.provisionalStartedTypecheckObjects[this.provisionalStartedTypecheckObjects.length] = pto; } }; TypeChecker.prototype.cleanStartedPTO = function () { for(var i = 0; i < this.provisionalStartedTypecheckObjects.length; i++) { if(this.provisionalStartedTypecheckObjects[i].typeCheckStatus >= this.typingContextStack.getContextID()) { this.provisionalStartedTypecheckObjects[i].typeCheckStatus = TypeScript.TypeCheckStatus.NotStarted; } } this.provisionalStartedTypecheckObjects = []; }; TypeChecker.prototype.collectTypes = function (ast) { if(ast.nodeType == TypeScript.NodeType.Script) { var script = ast; this.locationInfo = script.locationInfo; } var globalChain = new TypeScript.ScopeChain(this.gloMod, null, this.globalScope); var context = new TypeScript.TypeCollectionContext(globalChain, this); TypeScript.getAstWalkerFactory().walk(ast, TypeScript.preCollectTypes, TypeScript.postCollectTypes, null, context); }; TypeChecker.prototype.makeArrayType = function (type) { if(type.arrayCache == null) { type.arrayCache = new ArrayCache(); type.arrayCache.arrayType = new TypeScript.Type(); type.arrayCache.arrayType.elementType = type; type.arrayCache.arrayType.symbol = type.symbol; } return type.arrayCache.arrayType; }; TypeChecker.prototype.getParameterList = function (funcDecl, container) { var args = funcDecl.arguments; var parameterTable = null; var parameterBuilder = null; var len = args.members.length; var nonOptionalParams = 0; var result = []; if(len > 0) { parameterTable = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); parameterBuilder = new TypeScript.SymbolScopeBuilder(parameterTable, null, null, null, null, container); for(var i = 0; i < len; i++) { var parameter = args.members[i]; var paramDef = new TypeScript.ValueLocation(); var parameterSymbol = new TypeScript.ParameterSymbol(parameter.id.text, parameter.minChar, this.locationInfo.unitIndex, paramDef); parameterSymbol.declAST = parameter; parameterSymbol.funcDecl = funcDecl; parameter.id.sym = parameterSymbol; parameter.sym = parameterSymbol; paramDef.symbol = parameterSymbol; paramDef.typeLink = TypeScript.getTypeLink(parameter.typeExpr, this, false); parameterBuilder.enter(null, parameter, parameterSymbol, this.errorReporter, true, false, false); result[result.length] = parameterSymbol; if(!parameter.isOptionalArg()) { nonOptionalParams++; } } } return { parameters: result, nonOptionalParameterCount: nonOptionalParams }; }; TypeChecker.prototype.createFunctionSignature = function (funcDecl, container, scope, overloadGroupSym, addToScope) { var isExported = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Exported | TypeScript.FncFlags.ClassPropertyMethodExported) || container == this.gloMod; var isStatic = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Static); var isPrivate = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Private); var isDefinition = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Definition); var isAmbient = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Ambient); var isConstructor = funcDecl.isConstructMember() || funcDecl.isConstructor; var isGlobal = container == this.gloMod; var signature = new TypeScript.Signature(); var isLambda = funcDecl.fncFlags & TypeScript.FncFlags.IsFunctionExpression; if(funcDecl.returnTypeAnnotation || isDefinition) { signature.returnType = TypeScript.getTypeLink(funcDecl.returnTypeAnnotation, this, false); } else { signature.returnType = new TypeScript.TypeLink(); signature.returnType.type = this.anyType; } signature.hasVariableArgList = funcDecl.variableArgList; var sigData = this.getParameterList(funcDecl, container); signature.parameters = sigData.parameters; signature.nonOptionalParameterCount = sigData.nonOptionalParameterCount; funcDecl.signature = signature; signature.declAST = funcDecl; var useOverloadGroupSym = overloadGroupSym && overloadGroupSym.getType() && !overloadGroupSym.isAccessor() && (funcDecl.isSignature() || (isAmbient == TypeScript.hasFlag(overloadGroupSym.flags, TypeScript.SymbolFlags.Ambient))); if(useOverloadGroupSym && isPrivate != TypeScript.hasFlag(overloadGroupSym.flags, TypeScript.SymbolFlags.Private)) { this.errorReporter.simpleError(funcDecl, "Public/Private visibility of overloads does not agree"); } var groupType = useOverloadGroupSym ? overloadGroupSym.getType() : new TypeScript.Type(); if(isConstructor) { if(groupType.construct == null) { groupType.construct = new TypeScript.SignatureGroup(); } groupType.construct.addSignature(signature); groupType.construct.hasImplementation = !(funcDecl.isSignature()); if(groupType.construct.hasImplementation) { groupType.setHasImplementation(); } } else { if(funcDecl.isIndexerMember()) { if(groupType.index == null) { groupType.index = new TypeScript.SignatureGroup(); groupType.index.flags |= TypeScript.SignatureFlags.IsIndexer; } groupType.index.addSignature(signature); groupType.index.hasImplementation = !(funcDecl.isSignature()); if(groupType.index.hasImplementation) { groupType.setHasImplementation(); } } else { if(groupType.call == null) { groupType.call = new TypeScript.SignatureGroup(); } groupType.call.addSignature(signature); groupType.call.hasImplementation = !(funcDecl.isSignature()); if(groupType.call.hasImplementation) { groupType.setHasImplementation(); } } } var instanceType = groupType.instanceType; var funcName = null; var usedHint = false; if(funcDecl.name && !funcDecl.name.isMissing()) { funcName = funcDecl.name.text; } else { if(funcDecl.hint) { funcName = funcDecl.hint; usedHint = true; } } if(groupType.symbol == null) { groupType.symbol = new TypeScript.TypeSymbol(funcName ? funcName : this.anon, funcDecl.minChar, funcDecl.limChar - funcDecl.minChar, this.locationInfo.unitIndex, groupType); if(!useOverloadGroupSym) { groupType.symbol.declAST = funcDecl; } } if(isStatic) { groupType.symbol.flags |= TypeScript.SymbolFlags.Static; } if(isAmbient) { groupType.symbol.flags |= TypeScript.SymbolFlags.Ambient; } if(isPrivate) { groupType.symbol.flags |= TypeScript.SymbolFlags.Private; } groupType.symbol.isMethod = funcDecl.isMethod(); if(groupType.symbol.isMethod) { groupType.symbol.flags |= TypeScript.SymbolFlags.Property; } funcDecl.type = groupType; if(!isConstructor) { if(funcName && !isLambda && !funcDecl.isAccessor() && !usedHint) { if(addToScope) { if(funcDecl.isMethod() && isStatic) { if(!(container).type.members.publicMembers.add(funcName, groupType.symbol)) { this.errorReporter.duplicateIdentifier(funcDecl, funcName); } groupType.symbol.container = container; } else { if(overloadGroupSym == null || (overloadGroupSym.declAST && !(overloadGroupSym.declAST).isOverload && (container.isType()))) { scope.enter(container, funcDecl, groupType.symbol, this.errorReporter, !isPrivate && (isExported || isStatic || isGlobal), false, isAmbient); } } } else { if(!funcDecl.isSpecialFn()) { groupType.symbol.container = container; } } } else { if(!funcDecl.isSpecialFn()) { groupType.symbol.container = container; } } } if(useOverloadGroupSym) { var overloadGroupType = overloadGroupSym ? overloadGroupSym.getType() : null; var classType = groupType; if(classType != overloadGroupType) { if(classType.construct == null) { if(overloadGroupType && overloadGroupType.construct) { classType.construct = overloadGroupType.construct; } else { classType.construct = new TypeScript.SignatureGroup(); } } else { if(overloadGroupType) { if(overloadGroupType.construct) { classType.construct.signatures.concat(overloadGroupType.construct.signatures); } } } if(overloadGroupType) { if(classType.call == null) { classType.call = overloadGroupType.call; } else { if(overloadGroupType.call) { classType.call.signatures.concat(overloadGroupType.call.signatures); } } if(!isStatic) { if(classType.instanceType == null) { classType.instanceType = overloadGroupType.instanceType; } var instanceType = classType.instanceType; if(instanceType) { if(instanceType.call == null) { instanceType.call = overloadGroupType.call; } else { if(overloadGroupType.call) { instanceType.call.signatures.concat(overloadGroupType.call.signatures); } } } } if(classType.index == null) { classType.index = overloadGroupType.index; } else { if(overloadGroupType.index) { classType.index.signatures.concat(overloadGroupType.index.signatures); } } } } } return signature; }; TypeChecker.prototype.createAccessorSymbol = function (funcDecl, fgSym, enclosingClass, addToMembers, isClassProperty, scope, container) { var accessorSym = null; var sig = funcDecl.signature; var nameText = funcDecl.name.text; var isStatic = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Static); var isPrivate = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Private); if(fgSym == null) { var field = new TypeScript.ValueLocation(); accessorSym = new TypeScript.FieldSymbol(nameText, funcDecl.minChar, this.locationInfo.unitIndex, false, field); field.symbol = accessorSym; accessorSym.declAST = funcDecl; if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.GetAccessor)) { if(accessorSym.getter) { this.errorReporter.simpleError(funcDecl, "Redeclaration of property getter"); } accessorSym.getter = sig.declAST.type.symbol; } else { if(accessorSym.setter) { this.errorReporter.simpleError(funcDecl, "Redeclaration of property setter"); } accessorSym.setter = sig.declAST.type.symbol; } field.typeLink = TypeScript.getTypeLink(null, this, false); if(addToMembers) { if(enclosingClass) { if(!enclosingClass.members.publicMembers.add(nameText, accessorSym)) { this.errorReporter.duplicateIdentifier(funcDecl, accessorSym.name); } accessorSym.container = enclosingClass.symbol; } else { this.errorReporter.simpleError(funcDecl, "Accessor property may not be added in this context"); } } else { scope.enter(container, funcDecl, accessorSym, this.errorReporter, !isPrivate || isStatic, false, false); } if(isClassProperty) { accessorSym.flags |= TypeScript.SymbolFlags.Property; } if(isStatic) { accessorSym.flags |= TypeScript.SymbolFlags.Static; } if(isPrivate) { accessorSym.flags |= TypeScript.SymbolFlags.Private; } else { accessorSym.flags |= TypeScript.SymbolFlags.Public; } } else { accessorSym = (fgSym); if(isPrivate != TypeScript.hasFlag(accessorSym.flags, TypeScript.SymbolFlags.Private)) { this.errorReporter.simpleError(funcDecl, "Getter and setter accessors do not agree in visibility"); } if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.GetAccessor)) { if(accessorSym.getter) { this.errorReporter.simpleError(funcDecl, "Redeclaration of property getter"); } accessorSym.getter = funcDecl.type.symbol; } else { if(accessorSym.setter) { this.errorReporter.simpleError(funcDecl, "Redeclaration of property setter"); } accessorSym.setter = funcDecl.type.symbol; } } return accessorSym; }; TypeChecker.prototype.addBases = function (resultScope, type, baseContext) { resultScope.addParentScope(new TypeScript.SymbolTableScope(type.members, type.ambientMembers, type.getAllEnclosedTypes(), type.getAllAmbientEnclosedTypes(), type.symbol)); var i = 0; var parent; if(type.extendsList) { for(var len = type.extendsList.length; i < len; i++) { parent = type.extendsList[i]; if(baseContext.baseId == parent.typeID) { this.errorReporter.reportErrorFromSym(parent.symbol, "Type '" + baseContext.base + "' is recursively referenced as a base class of itself"); parent.symbol.flags |= TypeScript.SymbolFlags.RecursivelyReferenced; break; } this.addBases(resultScope, parent, baseContext); } } }; TypeChecker.prototype.scopeOf = function (type) { var resultScope = new TypeScript.SymbolAggregateScope(type.symbol); var baseContext = { base: type.symbol && type.symbol.name ? type.symbol.name : "{}", baseId: type.typeID }; this.addBases(resultScope, type, baseContext); return resultScope; }; TypeChecker.prototype.lookupMemberTypeSymbol = function (containingType, name) { var symbol = null; if(containingType.containedScope) { symbol = containingType.containedScope.find(name, false, true); } else { if(containingType.members) { symbol = containingType.members.allMembers.lookup(name); if(symbol == null && containingType.ambientMembers) { symbol = containingType.ambientMembers.allMembers.lookup(name); } } } if(symbol == null) { var typeMembers = containingType.getAllEnclosedTypes(); var ambientTypeMembers = containingType.getAllAmbientEnclosedTypes(); if(typeMembers) { symbol = typeMembers.allMembers.lookup(name); if(symbol == null && ambientTypeMembers) { symbol = ambientTypeMembers.allMembers.lookup(name); } } } if(symbol && symbol.isType()) { return symbol; } else { return null; } }; TypeChecker.prototype.findSymbolForDynamicModule = function (idText, currentFileName, search) { var originalIdText = idText; var symbol = search(idText); if(symbol == null) { if(!symbol) { idText = TypeScript.swapQuotes(originalIdText); symbol = search(idText); } if(!symbol) { idText = TypeScript.stripQuotes(originalIdText) + ".ts"; symbol = search(idText); } if(!symbol) { idText = TypeScript.stripQuotes(originalIdText) + ".str"; symbol = search(idText); } if(!symbol) { idText = TypeScript.stripQuotes(originalIdText) + ".d.ts"; symbol = search(idText); } if(!symbol) { idText = TypeScript.stripQuotes(originalIdText) + ".d.str"; symbol = search(idText); } if(!symbol && !TypeScript.isRelative(originalIdText)) { idText = originalIdText; var strippedIdText = TypeScript.stripQuotes(idText); var path = TypeScript.getRootFilePath(TypeScript.switchToForwardSlashes(currentFileName)); while(symbol == null && path != "") { idText = TypeScript.normalizePath(path + strippedIdText + ".ts"); symbol = search(idText); if(symbol == null) { idText = TypeScript.changePathToSTR(idText); symbol = search(idText); } if(symbol == null) { idText = TypeScript.changePathToDTS(idText); symbol = search(idText); } if(symbol == null) { idText = TypeScript.changePathToDSTR(idText); symbol = search(idText); } if(symbol == null) { if(path === '/') { path = ''; } else { path = TypeScript.normalizePath(path + ".."); path = path && path != '/' ? path + '/' : path; } } } } } return symbol; }; TypeChecker.prototype.resolveTypeMember = function (scope, dotNode) { var lhs = dotNode.operand1; var rhs = dotNode.operand2; var resultType = this.anyType; var lhsType = this.anyType; if(lhs && rhs && (rhs.nodeType == TypeScript.NodeType.Name)) { if(lhs.nodeType == TypeScript.NodeType.Dot) { lhsType = this.resolveTypeMember(scope, lhs); } else { if(lhs.nodeType == TypeScript.NodeType.Name) { var identifier = lhs; var symbol = scope.find(identifier.text, false, true); if(symbol == null) { this.errorReporter.unresolvedSymbol(identifier, identifier.actualText); } else { if(symbol.isType()) { var typeSymbol = symbol; if(typeSymbol.aliasLink && !typeSymbol.type && typeSymbol.aliasLink.alias.nodeType == TypeScript.NodeType.Name) { var modPath = (typeSymbol.aliasLink.alias).text; var modSym = this.findSymbolForDynamicModule(modPath, this.locationInfo.filename, function (id) { return scope.find(id, false, true); }); if(modSym) { typeSymbol.type = modSym.getType(); } } if(TypeScript.optimizeModuleCodeGen && symbol) { var symType = symbol.getType(); if(symType && typeSymbol.aliasLink && typeSymbol.onlyReferencedAsTypeRef) { var modDecl = symType.symbol.declAST; if(modDecl && TypeScript.hasFlag(modDecl.modFlags, TypeScript.ModuleFlags.IsDynamic)) { typeSymbol.onlyReferencedAsTypeRef = !this.resolvingBases; } } } if(!symbol.visible(scope, this)) { this.errorReporter.simpleError(lhs, "The symbol '" + identifier.actualText + "' is not visible at this point"); } lhsType = symbol.getType(); identifier.sym = symbol; } else { this.errorReporter.simpleError(lhs, "Expected type"); } } } } if(!lhsType) { lhsType = this.anyType; } if(lhsType != this.anyType) { var rhsIdentifier = rhs; var resultSymbol = this.lookupMemberTypeSymbol(lhsType, rhsIdentifier.text); if(resultSymbol == null) { resultType = this.anyType; this.errorReporter.simpleError(dotNode, "Expected type"); } else { resultType = resultSymbol.getType(); if(!resultSymbol.visible(scope, this)) { this.errorReporter.simpleError(lhs, "The symbol '" + (rhs).actualText + "' is not visible at this point"); } } rhsIdentifier.sym = resultType.symbol; } } if(resultType.isClass()) { resultType = resultType.instanceType; } return resultType; }; TypeChecker.prototype.resolveFuncDecl = function (funcDecl, scope, fgSym) { var functionGroupSymbol = this.createFunctionSignature(funcDecl, scope.container, scope, fgSym, false).declAST.type.symbol; var signatures; if(funcDecl.isConstructMember()) { signatures = functionGroupSymbol.type.construct.signatures; } else { if(funcDecl.isIndexerMember()) { signatures = functionGroupSymbol.type.getInstanceType().index.signatures; } else { signatures = functionGroupSymbol.type.call.signatures; } } var signature = signatures[signatures.length - 1]; var len = signature.parameters.length; for(var i = 0; i < len; i++) { var paramSym = signature.parameters[i]; this.resolveTypeLink(scope, paramSym.parameter.typeLink, true); } if(len && funcDecl.variableArgList) { if(!signature.parameters[len - 1].parameter.typeLink.type.elementType) { this.errorReporter.simpleErrorFromSym(signature.parameters[len - 1].parameter.symbol, "... parameter must have array type"); signature.parameters[len - 1].parameter.typeLink.type = this.makeArrayType(signature.parameters[len - 1].parameter.typeLink.type); } } this.resolveTypeLink(scope, signature.returnType, funcDecl.isSignature()); return functionGroupSymbol; }; TypeChecker.prototype.resolveVarDecl = function (varDecl, scope) { var field = new TypeScript.ValueLocation(); var fieldSymbol = new TypeScript.FieldSymbol(varDecl.id.text, varDecl.minChar, this.locationInfo.unitIndex, (varDecl.varFlags & TypeScript.VarFlags.Readonly) == TypeScript.VarFlags.None, field); fieldSymbol.transferVarFlags(varDecl.varFlags); field.symbol = fieldSymbol; fieldSymbol.declAST = varDecl; field.typeLink = TypeScript.getTypeLink(varDecl.typeExpr, this, varDecl.init == null); this.resolveTypeLink(scope, field.typeLink, true); varDecl.sym = fieldSymbol; varDecl.type = field.typeLink.type; return fieldSymbol; }; TypeChecker.prototype.resolveTypeLink = function (scope, typeLink, supplyVar) { var arrayCount = 0; if(typeLink.type == null) { var ast = typeLink.ast; if(ast) { while(typeLink.type == null) { switch(ast.nodeType) { case TypeScript.NodeType.Name: { var identifier = ast; var symbol = scope.find(identifier.text, false, true); if(symbol == null) { typeLink.type = this.anyType; this.errorReporter.unresolvedSymbol(identifier, identifier.actualText); } else { if(symbol.isType()) { if(!symbol.visible(scope, this)) { this.errorReporter.simpleError(ast, "The symbol '" + identifier.actualText + "' is not visible at this point"); } identifier.sym = symbol; typeLink.type = symbol.getType(); if(typeLink.type) { if(typeLink.type.isClass()) { typeLink.type = typeLink.type.instanceType; } } else { typeLink.type = this.anyType; } } else { typeLink.type = this.anyType; this.errorReporter.simpleError(ast, "Expected type"); } } break; } case TypeScript.NodeType.Dot: { typeLink.type = this.resolveTypeMember(scope, ast); break; } case TypeScript.NodeType.TypeRef: { var typeRef = ast; arrayCount = typeRef.arrayCount; ast = typeRef.term; if(ast == null) { typeLink.type = this.anyType; } break; } case TypeScript.NodeType.InterfaceDeclaration: { var interfaceDecl = ast; var interfaceType = new TypeScript.Type(); var interfaceSymbol = new TypeScript.TypeSymbol((interfaceDecl.name).text, ast.minChar, ast.limChar - ast.minChar, this.locationInfo.unitIndex, interfaceType); interfaceType.symbol = interfaceSymbol; interfaceType.members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); interfaceType.containedScope = new TypeScript.SymbolTableScope(interfaceType.members, null, null, null, interfaceSymbol); interfaceType.containedScope.container = interfaceSymbol; interfaceType.memberScope = interfaceType.containedScope; var memberList = interfaceDecl.members; var props = memberList.members; var propsLen = props.length; for(var j = 0; j < propsLen; j++) { var propDecl = props[j]; var propSym = null; var addMember = true; var id = null; if(propDecl.nodeType == TypeScript.NodeType.FuncDecl) { var funcDecl = propDecl; id = funcDecl.name; propSym = interfaceType.members.allMembers.lookup(funcDecl.getNameText()); addMember = (propSym == null); if(funcDecl.isSpecialFn()) { addMember = false; propSym = this.resolveFuncDecl(funcDecl, scope, interfaceSymbol); } else { propSym = this.resolveFuncDecl(funcDecl, scope, propSym); } funcDecl.type = (propSym).type; } else { id = (propDecl).id; propSym = this.resolveVarDecl(propDecl, scope); addMember = !id.isMissing(); } if(addMember) { if(id && TypeScript.hasFlag(id.flags, TypeScript.ASTFlags.OptionalName)) { propSym.flags |= TypeScript.SymbolFlags.Optional; } if(!interfaceType.members.allMembers.add(propSym.name, propSym)) { this.errorReporter.duplicateIdentifier(ast, propSym.name); } } } ast.type = interfaceType; typeLink.type = interfaceType; break; } case TypeScript.NodeType.FuncDecl: { var tsym = this.resolveFuncDecl(ast, scope, null); typeLink.type = tsym.type; break; } default: { typeLink.type = this.anyType; this.errorReporter.simpleError(ast, "Expected type"); break; } } } } for(var count = arrayCount; count > 0; count--) { typeLink.type = this.makeArrayType(typeLink.type); } if(supplyVar && (typeLink.type == null)) { typeLink.type = this.anyType; } if(typeLink.ast) { typeLink.ast.type = typeLink.type; } } }; TypeChecker.prototype.resolveBaseTypeLink = function (typeLink, scope) { this.resolvingBases = true; this.resolveTypeLink(scope, typeLink, true); this.resolvingBases = false; var extendsType = null; if(typeLink.type.isClass()) { extendsType = typeLink.type.instanceType; } else { extendsType = typeLink.type; } return extendsType; }; TypeChecker.prototype.findMostApplicableSignature = function (signatures, args) { if(signatures.length == 1) { return { sig: signatures[0].signature, ambiguous: false }; } var best = signatures[0]; var Q = null; var AType = null; var PType = null; var QType = null; var ambiguous = false; for(var qSig = 1; qSig < signatures.length; qSig++) { Q = signatures[qSig]; var i = 0; for(i = 0; args && i < args.members.length; i++) { AType = args.members[i].type; PType = i < best.signature.parameters.length ? best.signature.parameters[i].getType() : best.signature.parameters[best.signature.parameters.length - 1].getType().elementType; QType = i < Q.signature.parameters.length ? Q.signature.parameters[i].getType() : Q.signature.parameters[Q.signature.parameters.length - 1].getType().elementType; if(this.typesAreIdentical(PType, QType)) { continue; } else { if(this.typesAreIdentical(AType, PType)) { break; } else { if(this.typesAreIdentical(AType, QType)) { best = Q; break; } else { if(this.sourceIsSubtypeOfTarget(PType, QType)) { break; } else { if(this.sourceIsSubtypeOfTarget(QType, PType)) { best = Q; break; } else { if(Q.hadProvisionalErrors) { break; } else { if(best.hadProvisionalErrors) { best = Q; break; } } } } } } } } if(!args || i == args.members.length) { var collection = { getLength: function () { return 2; }, setTypeAtIndex: function (index, type) { }, getTypeAtIndex: function (index) { return index ? Q.signature.returnType.type : best.signature.returnType.type; } }; var bct = this.findBestCommonType(best.signature.returnType.type, null, collection, true); ambiguous = !bct; } else { ambiguous = false; } } return { sig: best.signature, ambiguous: ambiguous }; }; TypeChecker.prototype.getApplicableSignatures = function (signatures, args, comparisonInfo) { var applicableSigs = []; var memberType = null; var miss = false; var cxt = null; var hadProvisionalErrors = false; for(var i = 0; i < signatures.length; i++) { miss = false; for(var j = 0; j < args.members.length; j++) { if(j >= signatures[i].parameters.length) { continue; } memberType = signatures[i].parameters[j].getType(); if(signatures[i].declAST.variableArgList && (j >= signatures[i].nonOptionalParameterCount - 1) && memberType.isArray()) { memberType = memberType.elementType; } if(memberType == this.anyType) { continue; } else { if(args.members[j].nodeType == TypeScript.NodeType.FuncDecl) { if(this.typeFlow.functionInterfaceType && memberType == this.typeFlow.functionInterfaceType) { continue; } if(!this.canContextuallyTypeFunction(memberType, args.members[j], true)) { if(this.canContextuallyTypeFunction(memberType, args.members[j], false)) { this.typeFlow.typeCheck(args.members[j]); if(!this.sourceIsAssignableToTarget(args.members[j].type, memberType, comparisonInfo)) { break; } } else { break; } } else { this.typeCheckWithContextualType(memberType, true, true, args.members[j]); this.cleanStartedPTO(); hadProvisionalErrors = this.hadProvisionalErrors(); if(!this.sourceIsAssignableToTarget(args.members[j].type, memberType, comparisonInfo)) { if(comparisonInfo) { comparisonInfo.setMessage("Could not apply type '" + memberType.getTypeName() + "' to argument " + (j + 1) + ", which is of type '" + args.members[j].type.getTypeName() + "'"); } miss = true; } this.resetProvisionalErrors(); if(miss) { break; } } } else { if(args.members[j].nodeType == TypeScript.NodeType.ObjectLit) { if(this.typeFlow.objectInterfaceType && memberType == this.typeFlow.objectInterfaceType) { continue; } this.typeCheckWithContextualType(memberType, true, true, args.members[j]); this.cleanStartedPTO(); hadProvisionalErrors = this.hadProvisionalErrors(); if(!this.sourceIsAssignableToTarget(args.members[j].type, memberType, comparisonInfo)) { if(comparisonInfo) { comparisonInfo.setMessage("Could not apply type '" + memberType.getTypeName() + "' to argument " + (j + 1) + ", which is of type '" + args.members[j].type.getTypeName() + "'"); } miss = true; } this.resetProvisionalErrors(); if(miss) { break; } } else { if(args.members[j].nodeType == TypeScript.NodeType.ArrayLit) { if(this.typeFlow.arrayInterfaceType && memberType == this.typeFlow.arrayInterfaceType) { continue; } this.typeCheckWithContextualType(memberType, true, true, args.members[j]); this.cleanStartedPTO(); hadProvisionalErrors = this.hadProvisionalErrors(); if(!this.sourceIsAssignableToTarget(args.members[j].type, memberType, comparisonInfo)) { if(comparisonInfo) { comparisonInfo.setMessage("Could not apply type '" + memberType.getTypeName() + "' to argument " + (j + 1) + ", which is of type '" + args.members[j].type.getTypeName() + "'"); } break; } this.resetProvisionalErrors(); if(miss) { break; } } } } } } if(j == args.members.length) { applicableSigs[applicableSigs.length] = { signature: signatures[i], hadProvisionalErrors: hadProvisionalErrors }; } hadProvisionalErrors = false; } return applicableSigs; }; TypeChecker.prototype.canContextuallyTypeFunction = function (candidateType, funcDecl, beStringent) { if(funcDecl.isParenthesized || funcDecl.isMethod() || beStringent && funcDecl.returnTypeAnnotation || funcDecl.isInlineCallLiteral) { return false; } beStringent = beStringent || (this.typeFlow.functionInterfaceType == candidateType); if(!beStringent) { return true; } if(!funcDecl.signature) { this.createFunctionSignature(funcDecl, this.typeFlow.scope.container, this.typeFlow.scope, null, null); this.typeFlow.typeCheck(funcDecl); } var signature = funcDecl.signature; var paramLen = signature.parameters.length; for(var i = 0; i < paramLen; i++) { var param = signature.parameters[i]; var symbol = param; var argDecl = symbol.declAST; if(beStringent && argDecl.typeExpr) { return false; } } if(candidateType.construct && candidateType.call) { return false; } var candidateSigs = candidateType.construct ? candidateType.construct : candidateType.call; if(!candidateSigs || candidateSigs.signatures.length > 1) { return false; } return true; }; TypeChecker.prototype.canContextuallyTypeObjectLiteral = function (targetType, objectLit) { if(targetType == this.typeFlow.objectInterfaceType) { return true; } var memberDecls = objectLit.operand; if(!(memberDecls && targetType.memberScope)) { return false; } var id = null; var targetMember = null; var text = ""; var foundSyms = { }; for(var i = 0; i < memberDecls.members.length; i++) { id = (memberDecls.members[i]).operand1; if(id.nodeType == TypeScript.NodeType.Name) { text = (id).text; } else { if(id.nodeType == TypeScript.NodeType.QString) { var idText = (id).text; text = idText.substring(1, idText.length - 1); } else { return false; } } targetMember = targetType.memberScope.find(text, true, false); if(!targetMember) { return false; } foundSyms[text] = true; } var targetMembers = targetType.memberScope.getAllValueSymbolNames(true); for(var i = 0; i < targetMembers.length; i++) { var memberName = targetMembers[i]; var memberSym = targetType.memberScope.find(memberName, true, false); if(!foundSyms[targetMembers[i]] && !TypeScript.hasFlag(memberSym.flags, TypeScript.SymbolFlags.Optional)) { return false; } } return true; }; TypeChecker.prototype.widenType = function (t) { if(t == this.undefinedType || t == this.nullType) { return this.anyType; } return t; }; TypeChecker.prototype.isNullOrUndefinedType = function (t) { return t == this.undefinedType || t == this.nullType; }; TypeChecker.prototype.findBestCommonType = function (initialType, targetType, collection, acceptVoid, comparisonInfo) { var i = 0; var len = collection.getLength(); var nlastChecked = 0; var bestCommonType = initialType; if(targetType) { bestCommonType = bestCommonType ? bestCommonType.mergeOrdered(targetType, this, acceptVoid) : targetType; } var convergenceType = bestCommonType; while(nlastChecked < len) { for(i = 0; i < len; i++) { if(i == nlastChecked) { continue; } if(convergenceType && (bestCommonType = convergenceType.mergeOrdered(collection.getTypeAtIndex(i), this, acceptVoid, comparisonInfo))) { convergenceType = bestCommonType; } if(bestCommonType == this.anyType || bestCommonType == null) { break; } else { if(targetType) { collection.setTypeAtIndex(i, targetType); } } } if(convergenceType && bestCommonType) { break; } nlastChecked++; if(nlastChecked < len) { convergenceType = collection.getTypeAtIndex(nlastChecked); } } return acceptVoid ? bestCommonType : (bestCommonType == this.voidType ? null : bestCommonType); }; TypeChecker.prototype.typesAreIdentical = function (t1, t2) { if(t1 == t2) { return true; } if(!t1 || !t2) { return false; } if(t1.isClass() || t1.isClassInstance()) { return false; } var comboId = (t2.typeID << 16) | t1.typeID; if(this.identicalCache[comboId]) { return true; } if((t1.typeFlags & TypeScript.TypeFlags.IsEnum) || (t2.typeFlags & TypeScript.TypeFlags.IsEnum)) { return false; } if(t1.isArray() || t2.isArray()) { if(!(t1.isArray() && t2.isArray())) { return false; } this.identicalCache[comboId] = false; var ret = this.typesAreIdentical(t1.elementType, t2.elementType); if(ret) { this.subtypeCache[comboId] = true; } else { this.subtypeCache[comboId] = undefined; } return ret; } if(t1.primitiveTypeClass != t2.primitiveTypeClass) { return false; } this.identicalCache[comboId] = false; if(t1.memberScope && t2.memberScope) { var t1MemberKeys = t1.memberScope.getAllValueSymbolNames(true).sort(); var t2MemberKeys = t2.memberScope.getAllValueSymbolNames(true).sort(); if(t1MemberKeys.length != t2MemberKeys.length) { this.identicalCache[comboId] = undefined; return false; } var t1MemberSymbol = null; var t2MemberSymbol = null; var t1MemberType = null; var t2MemberType = null; for(var iMember = 0; iMember < t1MemberKeys.length; iMember++) { if(t1MemberKeys[iMember] != t2MemberKeys[iMember]) { this.identicalCache[comboId] = undefined; return false; } t1MemberSymbol = t1.memberScope.find(t1MemberKeys[iMember], false, false); t2MemberSymbol = t2.memberScope.find(t2MemberKeys[iMember], false, false); if((t1MemberSymbol.flags & TypeScript.SymbolFlags.Optional) != (t2MemberSymbol.flags & TypeScript.SymbolFlags.Optional)) { this.identicalCache[comboId] = undefined; return false; } t1MemberType = t1MemberSymbol.getType(); t2MemberType = t2MemberSymbol.getType(); if(t1MemberType && t2MemberType && (this.identicalCache[(t2MemberType.typeID << 16) | t1MemberType.typeID] != undefined)) { continue; } if(!this.typesAreIdentical(t1MemberType, t2MemberType)) { this.identicalCache[comboId] = undefined; return false; } } } else { if(t1.memberScope || t2.memberScope) { this.identicalCache[comboId] = undefined; return false; } } if(!this.signatureGroupsAreIdentical(t1.call, t2.call)) { this.identicalCache[comboId] = undefined; return false; } if(!this.signatureGroupsAreIdentical(t1.construct, t2.construct)) { this.identicalCache[comboId] = undefined; return false; } if(!this.signatureGroupsAreIdentical(t1.index, t2.index)) { this.identicalCache[comboId] = undefined; return false; } this.identicalCache[comboId] = true; return true; }; TypeChecker.prototype.signatureGroupsAreIdentical = function (sg1, sg2) { if(sg1 == sg2) { return true; } if(!sg1 || !sg2) { return false; } if(sg1.signatures.length != sg2.signatures.length) { return false; } var sig1 = null; var sig2 = null; var sigsMatch = false; for(var iSig1 = 0; iSig1 < sg1.signatures.length; iSig1++) { sig1 = sg1.signatures[iSig1]; for(var iSig2 = 0; iSig2 < sg2.signatures.length; iSig2++) { sig2 = sg2.signatures[iSig2]; if(this.signaturesAreIdentical(sig1, sig2)) { sigsMatch = true; break; } } if(sigsMatch) { sigsMatch = false; continue; } return false; } return true; }; TypeChecker.prototype.signaturesAreIdentical = function (s1, s2) { if(s1.hasVariableArgList != s2.hasVariableArgList) { return false; } if(s1.nonOptionalParameterCount != s2.nonOptionalParameterCount) { return false; } if(s1.parameters.length != s2.parameters.length) { return false; } if(!this.typesAreIdentical(s1.returnType.type, s2.returnType.type)) { return false; } for(var iParam = 0; iParam < s1.parameters.length; iParam++) { if(!this.typesAreIdentical(s1.parameters[iParam].parameter.typeLink.type, s2.parameters[iParam].parameter.typeLink.type)) { return false; } } return true; }; TypeChecker.prototype.sourceIsSubtypeOfTarget = function (source, target, comparisonInfo) { return this.sourceIsRelatableToTarget(source, target, false, this.subtypeCache, comparisonInfo); }; TypeChecker.prototype.signatureGroupIsSubtypeOfTarget = function (sg1, sg2, comparisonInfo) { return this.signatureGroupIsRelatableToTarget(sg1, sg2, false, this.subtypeCache, comparisonInfo); }; TypeChecker.prototype.signatureIsSubtypeOfTarget = function (s1, s2, comparisonInfo) { return this.signatureIsRelatableToTarget(s1, s2, false, this.subtypeCache, comparisonInfo); }; TypeChecker.prototype.sourceIsAssignableToTarget = function (source, target, comparisonInfo) { return this.sourceIsRelatableToTarget(source, target, true, this.assignableCache, comparisonInfo); }; TypeChecker.prototype.signatureGroupIsAssignableToTarget = function (sg1, sg2, comparisonInfo) { return this.signatureGroupIsRelatableToTarget(sg1, sg2, true, this.assignableCache, comparisonInfo); }; TypeChecker.prototype.signatureIsAssignableToTarget = function (s1, s2, comparisonInfo) { return this.signatureIsRelatableToTarget(s1, s2, true, this.assignableCache, comparisonInfo); }; TypeChecker.prototype.sourceIsRelatableToTarget = function (source, target, assignableTo, comparisonCache, comparisonInfo) { if(source == target) { return true; } if(!(source && target)) { return true; } var comboId = (source.typeID << 16) | target.typeID; if(comparisonCache[comboId] != undefined) { return true; } if(assignableTo) { if(source == this.anyType || target == this.anyType) { return true; } } else { if(target == this.anyType) { return true; } } if(source == this.undefinedType) { return true; } if((source == this.nullType) && (target != this.undefinedType && target != this.voidType)) { return true; } if(target == this.numberType && (source.typeFlags & TypeScript.TypeFlags.IsEnum)) { return true; } if(source == this.numberType && (target.typeFlags & TypeScript.TypeFlags.IsEnum)) { return true; } if((source.typeFlags & TypeScript.TypeFlags.IsEnum) || (target.typeFlags & TypeScript.TypeFlags.IsEnum)) { return false; } if(source.isArray() || target.isArray()) { if(!(source.isArray() && target.isArray())) { return false; } comparisonCache[comboId] = false; var ret = this.sourceIsRelatableToTarget(source.elementType, target.elementType, assignableTo, comparisonCache, comparisonInfo); if(ret) { comparisonCache[comboId] = true; } else { comparisonCache[comboId] = undefined; } return ret; } if(source.primitiveTypeClass != target.primitiveTypeClass) { if(target.primitiveTypeClass == TypeScript.Primitive.None) { if(source == this.numberType && this.typeFlow.numberInterfaceType) { source = this.typeFlow.numberInterfaceType; } else { if(source == this.stringType && this.typeFlow.stringInterfaceType) { source = this.typeFlow.stringInterfaceType; } else { if(source == this.booleanType && this.typeFlow.booleanInterfaceType) { source = this.typeFlow.booleanInterfaceType; } else { return false; } } } } else { return false; } } comparisonCache[comboId] = false; if(source.hasBase(target)) { comparisonCache[comboId] = true; return true; } if(this.typeFlow.objectInterfaceType && target == this.typeFlow.objectInterfaceType) { return true; } if(this.typeFlow.functionInterfaceType && (source.call || source.construct) && target == this.typeFlow.functionInterfaceType) { return true; } if(target.isClass() || target.isClassInstance()) { comparisonCache[comboId] = undefined; return false; } if(target.memberScope && source.memberScope) { var mPropKeys = target.memberScope.getAllValueSymbolNames(true); var mProp = null; var nProp = null; var mPropType = null; var nPropType = null; var inferenceSymbol = null; for(var iMProp = 0; iMProp < mPropKeys.length; iMProp++) { mProp = target.memberScope.find(mPropKeys[iMProp], false, false); nProp = source.memberScope.find(mPropKeys[iMProp], false, false); if(mProp.name == "arguments" && this.typeFlow.iargumentsInterfaceType && (this.typeFlow.iargumentsInterfaceType.symbol.flags & TypeScript.SymbolFlags.CompilerGenerated) && mProp.kind() == TypeScript.SymbolKind.Variable && (mProp).variable.typeLink.type == this.typeFlow.iargumentsInterfaceType) { continue; } if(mProp.isInferenceSymbol()) { inferenceSymbol = mProp; if(inferenceSymbol.typeCheckStatus == TypeScript.TypeCheckStatus.NotStarted) { this.typeFlow.typeCheck(mProp.declAST); } } mPropType = mProp.getType(); if(!nProp) { if(this.typeFlow.objectInterfaceType) { nProp = this.typeFlow.objectInterfaceType.memberScope.find(mPropKeys[iMProp], false, false); } if(!nProp) { if(this.typeFlow.functionInterfaceType && (mPropType.call || mPropType.construct)) { nProp = this.typeFlow.functionInterfaceType.memberScope.find(mPropKeys[iMProp], false, false); } if(!nProp) { if(!(mProp.flags & TypeScript.SymbolFlags.Optional)) { comparisonCache[comboId] = undefined; if(comparisonInfo) { comparisonInfo.flags |= TypeScript.TypeRelationshipFlags.RequiredPropertyIsMissing; comparisonInfo.addMessageToFront("Type '" + source.getTypeName() + "' is missing property '" + mPropKeys[iMProp] + "' from type '" + target.getTypeName() + "'"); } return false; } else { continue; } } } } if(nProp.isInferenceSymbol()) { inferenceSymbol = nProp; if(inferenceSymbol.typeCheckStatus == TypeScript.TypeCheckStatus.NotStarted) { this.typeFlow.typeCheck(nProp.declAST); } } nPropType = nProp.getType(); if(mPropType && nPropType && (comparisonCache[(nPropType.typeID << 16) | mPropType.typeID] != undefined)) { continue; } if(!this.sourceIsRelatableToTarget(nPropType, mPropType, assignableTo, comparisonCache, comparisonInfo)) { comparisonCache[comboId] = undefined; if(comparisonInfo) { comparisonInfo.flags |= TypeScript.TypeRelationshipFlags.IncompatiblePropertyTypes; comparisonInfo.addMessageToFront("Types of property '" + mProp.name + "' of types '" + source.getTypeName() + "' and '" + target.getTypeName() + "' are incompatible"); } return false; } } } if(source.call || target.call) { if(!this.signatureGroupIsRelatableToTarget(source.call, target.call, assignableTo, comparisonCache, comparisonInfo)) { if(comparisonInfo) { if(source.call && target.call) { comparisonInfo.addMessageToFront("Call signatures of types '" + source.getTypeName() + "' and '" + target.getTypeName() + "' are incompatible"); } else { var hasSig = target.call ? target.getTypeName() : source.getTypeName(); var lacksSig = !target.call ? target.getTypeName() : source.getTypeName(); comparisonInfo.setMessage("Type '" + hasSig + "' requires a call signature, but Type '" + lacksSig + "' lacks one"); } comparisonInfo.flags |= TypeScript.TypeRelationshipFlags.IncompatibleSignatures; } comparisonCache[comboId] = undefined; return false; } } if(source.construct || target.construct) { if(!this.signatureGroupIsRelatableToTarget(source.construct, target.construct, assignableTo, comparisonCache, comparisonInfo)) { if(comparisonInfo) { if(source.construct && target.construct) { comparisonInfo.addMessageToFront("Construct signatures of types '" + source.getTypeName() + "' and '" + target.getTypeName() + "' are incompatible"); } else { var hasSig = target.construct ? target.getTypeName() : source.getTypeName(); var lacksSig = !target.construct ? target.getTypeName() : source.getTypeName(); comparisonInfo.setMessage("Type '" + hasSig + "' requires a construct signature, but Type '" + lacksSig + "' lacks one"); } comparisonInfo.flags |= TypeScript.TypeRelationshipFlags.IncompatibleSignatures; } comparisonCache[comboId] = undefined; return false; } } if(target.index) { var targetIndex = !target.index && this.typeFlow.objectInterfaceType ? this.typeFlow.objectInterfaceType.index : target.index; var sourceIndex = !source.index && this.typeFlow.objectInterfaceType ? this.typeFlow.objectInterfaceType.index : source.index; if(!this.signatureGroupIsRelatableToTarget(sourceIndex, targetIndex, assignableTo, comparisonCache, comparisonInfo)) { if(comparisonInfo) { comparisonInfo.addMessageToFront("Index signatures of types '" + source.getTypeName() + "' and '" + target.getTypeName() + "' are incompatible"); comparisonInfo.flags |= TypeScript.TypeRelationshipFlags.IncompatibleSignatures; } comparisonCache[comboId] = undefined; return false; } } comparisonCache[comboId] = true; return true; }; TypeChecker.prototype.signatureGroupIsRelatableToTarget = function (sourceSG, targetSG, assignableTo, comparisonCache, comparisonInfo) { if(sourceSG == targetSG) { return true; } if(!(sourceSG && targetSG)) { return false; } var mSig = null; var nSig = null; var foundMatch = false; for(var iMSig = 0; iMSig < targetSG.signatures.length; iMSig++) { mSig = targetSG.signatures[iMSig]; for(var iNSig = 0; iNSig < sourceSG.signatures.length; iNSig++) { nSig = sourceSG.signatures[iNSig]; if(this.signatureIsRelatableToTarget(nSig, mSig, assignableTo, comparisonCache, comparisonInfo)) { foundMatch = true; break; } } if(foundMatch) { foundMatch = false; continue; } return false; } return true; }; TypeChecker.prototype.signatureIsRelatableToTarget = function (sourceSig, targetSig, assignableTo, comparisonCache, comparisonInfo) { if(!sourceSig.parameters || !targetSig.parameters) { return false; } var targetVarArgCount = targetSig.hasVariableArgList ? targetSig.nonOptionalParameterCount - 1 : targetSig.nonOptionalParameterCount; var sourceVarArgCount = sourceSig.hasVariableArgList ? sourceSig.nonOptionalParameterCount - 1 : sourceSig.nonOptionalParameterCount; if(sourceVarArgCount > targetVarArgCount && !targetSig.hasVariableArgList) { if(comparisonInfo) { comparisonInfo.flags |= TypeScript.TypeRelationshipFlags.SourceSignatureHasTooManyParameters; comparisonInfo.addMessageToFront("Call signature expects " + targetVarArgCount + " or fewer parameters"); } return false; } var sourceReturnType = sourceSig.returnType.type; var targetReturnType = targetSig.returnType.type; if(targetReturnType != this.voidType) { if(!this.sourceIsRelatableToTarget(sourceReturnType, targetReturnType, assignableTo, comparisonCache, comparisonInfo)) { if(comparisonInfo) { comparisonInfo.flags |= TypeScript.TypeRelationshipFlags.IncompatibleReturnTypes; } return false; } } var len = (sourceVarArgCount < targetVarArgCount && sourceSig.hasVariableArgList) ? targetVarArgCount : sourceVarArgCount; var sourceParamType = null; var targetParamType = null; var sourceParamName = ""; var targetParamName = ""; for(var iSource = 0, iTarget = 0; iSource < len; iSource++ , iTarget++) { if(!sourceSig.hasVariableArgList || iSource < sourceVarArgCount) { sourceParamType = (sourceSig.parameters[iSource]).parameter.typeLink.type; sourceParamName = (sourceSig.parameters[iSource]).parameter.symbol.name; } else { if(iSource == sourceVarArgCount) { sourceParamType = (sourceSig.parameters[iSource]).parameter.typeLink.type; if(sourceParamType.elementType) { sourceParamType = sourceParamType.elementType; } sourceParamName = (sourceSig.parameters[iSource]).parameter.symbol.name; } } if(iTarget < targetSig.parameters.length && iTarget < targetVarArgCount) { targetParamType = (targetSig.parameters[iTarget]).parameter.typeLink.type; targetParamName = (targetSig.parameters[iTarget]).parameter.symbol.name; } else { if(targetSig.hasVariableArgList && iTarget == targetVarArgCount) { targetParamType = (targetSig.parameters[iTarget]).parameter.typeLink.type; if(targetParamType.elementType) { targetParamType = targetParamType.elementType; } targetParamName = (targetSig.parameters[iTarget]).parameter.symbol.name; } } if(!(this.sourceIsRelatableToTarget(sourceParamType, targetParamType, assignableTo, comparisonCache, comparisonInfo) || this.sourceIsRelatableToTarget(targetParamType, sourceParamType, assignableTo, comparisonCache, comparisonInfo))) { if(comparisonInfo) { comparisonInfo.flags |= TypeScript.TypeRelationshipFlags.IncompatibleParameterTypes; } return false; } } return true; }; return TypeChecker; })(); TypeScript.TypeChecker = TypeChecker; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var Continuation = (function () { function Continuation(normalBlock) { this.normalBlock = normalBlock; this.exceptionBlock = -1; } return Continuation; })(); TypeScript.Continuation = Continuation; function getBaseTypeLinks(bases, baseTypeLinks) { if(bases) { var len = bases.members.length; if(baseTypeLinks == null) { baseTypeLinks = new Array(); } for(var i = 0; i < len; i++) { var baseExpr = bases.members[i]; var name = baseExpr; var typeLink = new TypeScript.TypeLink(); typeLink.ast = name; baseTypeLinks[baseTypeLinks.length] = typeLink; } } return baseTypeLinks; } function getBases(type, typeDecl) { type.extendsTypeLinks = getBaseTypeLinks(typeDecl.extendsList, type.extendsTypeLinks); type.implementsTypeLinks = getBaseTypeLinks(typeDecl.implementsList, type.implementsTypeLinks); } function addPrototypeField(classType, ast, context) { var field = new TypeScript.ValueLocation(); field.typeLink = new TypeScript.TypeLink(); field.typeLink.ast = ast; field.typeLink.type = classType.instanceType; var fieldSymbol = new TypeScript.FieldSymbol("prototype", ast.minChar, context.checker.locationInfo.unitIndex, true, field); fieldSymbol.flags |= (TypeScript.SymbolFlags.Property | TypeScript.SymbolFlags.BuiltIn); field.symbol = fieldSymbol; fieldSymbol.declAST = ast; classType.members.addPublicMember("prototype", fieldSymbol); } function createNewConstructGroupForType(type) { var signature = new TypeScript.Signature(); signature.returnType = new TypeScript.TypeLink(); signature.returnType.type = type.instanceType; signature.parameters = []; type.construct = new TypeScript.SignatureGroup(); type.construct.addSignature(signature); } TypeScript.createNewConstructGroupForType = createNewConstructGroupForType; function cloneParentConstructGroupForChildType(child, parent) { child.construct = new TypeScript.SignatureGroup(); var sig = null; if(!parent.construct) { createNewConstructGroupForType(parent); } for(var i = 0; i < parent.construct.signatures.length; i++) { sig = new TypeScript.Signature(); sig.parameters = parent.construct.signatures[i].parameters; sig.nonOptionalParameterCount = parent.construct.signatures[i].nonOptionalParameterCount; sig.typeCheckStatus = parent.construct.signatures[i].typeCheckStatus; sig.declAST = parent.construct.signatures[i].declAST; sig.returnType = new TypeScript.TypeLink(); sig.returnType.type = child.instanceType; child.construct.addSignature(sig); } } TypeScript.cloneParentConstructGroupForChildType = cloneParentConstructGroupForChildType; TypeScript.globalId = "__GLO"; function findTypeSymbolInScopeChain(name, scopeChain) { var symbol = scopeChain.scope.find(name, false, true); if(symbol == null && scopeChain.previous) { symbol = findTypeSymbolInScopeChain(name, scopeChain.previous); } return symbol; } function findSymbolFromAlias(alias, context) { var symbol = null; switch(alias.nodeType) { case TypeScript.NodeType.Name: { var name = (alias).text; var isDynamic = TypeScript.isQuoted(name); var findSym = function (id) { if(context.members) { return context.members.lookup(name); } else { return findTypeSymbolInScopeChain(name, context.topLevelScope); } }; if(isDynamic) { symbol = context.tcContext.checker.findSymbolForDynamicModule(name, context.tcContext.script.locationInfo.filename, findSym); } else { symbol = findSym(name); } break; } case TypeScript.NodeType.Dot: { var dottedExpr = alias; var op1Sym = findSymbolFromAlias(dottedExpr.operand1, context); if(op1Sym && op1Sym.getType()) { symbol = findSymbolFromAlias(dottedExpr.operand2, context); } break; } default: { break; } } if(symbol) { var symType = symbol.getType(); if(symType) { var members = symType.members; if(members) { context.members = members.publicMembers; } } } return symbol; } function preCollectImportTypes(ast, parent, context) { var scopeChain = context.scopeChain; var typeSymbol = null; var modType = null; var importDecl = ast; var aliasedModSymbol = findSymbolFromAlias(importDecl.alias, { topLevelScope: scopeChain, members: null, tcContext: context }); var isGlobal = context.scopeChain.container == context.checker.gloMod; if(aliasedModSymbol) { var aliasedModType = aliasedModSymbol.getType(); if(aliasedModType) { modType = aliasedModType; } } typeSymbol = new TypeScript.TypeSymbol(importDecl.id.text, importDecl.id.minChar, importDecl.limChar - importDecl.minChar, context.checker.locationInfo.unitIndex, modType); typeSymbol.aliasLink = importDecl; if(context.scopeChain.moduleDecl) { typeSymbol.flags |= TypeScript.SymbolFlags.ModuleMember; typeSymbol.declModule = context.scopeChain.moduleDecl; } typeSymbol.declAST = importDecl; importDecl.id.sym = typeSymbol; scopeChain.scope.enter(scopeChain.container, ast, typeSymbol, context.checker.errorReporter, isGlobal, true, false); scopeChain.scope.enter(scopeChain.container, ast, typeSymbol, context.checker.errorReporter, isGlobal, false, false); return true; } TypeScript.preCollectImportTypes = preCollectImportTypes; function preCollectModuleTypes(ast, parent, context) { var scopeChain = context.scopeChain; var moduleDecl = ast; var isAmbient = TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.Ambient); var isEnum = TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsEnum); var isGlobal = context.scopeChain.container == context.checker.gloMod; var isExported = TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.Exported); var modName = (moduleDecl.name).text; var isDynamic = TypeScript.isQuoted(modName); var symbol = scopeChain.scope.findLocal(modName, false, false); var typeSymbol = null; var modType = null; if((symbol == null) || (symbol.kind() != TypeScript.SymbolKind.Type)) { if(modType == null) { var enclosedTypes = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); var ambientEnclosedTypes = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); modType = new TypeScript.ModuleType(enclosedTypes, ambientEnclosedTypes); if(isEnum) { modType.typeFlags |= TypeScript.TypeFlags.IsEnum; } modType.members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); modType.ambientMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); modType.setHasImplementation(); } typeSymbol = new TypeScript.TypeSymbol(modName, moduleDecl.name.minChar, modName.length, context.checker.locationInfo.unitIndex, modType); typeSymbol.isDynamic = TypeScript.isQuoted(moduleDecl.prettyName); if(context.scopeChain.moduleDecl) { typeSymbol.declModule = context.scopeChain.moduleDecl; } typeSymbol.declAST = moduleDecl; typeSymbol.prettyName = moduleDecl.prettyName; scopeChain.scope.enter(scopeChain.container, ast, typeSymbol, context.checker.errorReporter, isExported || isGlobal, true, isAmbient); scopeChain.scope.enter(scopeChain.container, ast, typeSymbol, context.checker.errorReporter, isExported || isGlobal, false, isAmbient); modType.symbol = typeSymbol; } else { if(symbol && symbol.declAST && symbol.declAST.nodeType != TypeScript.NodeType.ModuleDeclaration) { context.checker.errorReporter.simpleError(moduleDecl, "Conflicting symbol name for module '" + modName + "'"); } typeSymbol = symbol; var publicEnclosedTypes = typeSymbol.type.getAllEnclosedTypes().publicMembers; var publicEnclosedTypesTable = (publicEnclosedTypes == null) ? new TypeScript.StringHashTable() : publicEnclosedTypes; var enclosedTypes = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(publicEnclosedTypesTable, new TypeScript.StringHashTable())); var publicEnclosedAmbientTypes = typeSymbol.type.getAllAmbientEnclosedTypes().publicMembers; var publicAmbientEnclosedTypesTable = (publicEnclosedAmbientTypes == null) ? new TypeScript.StringHashTable() : publicEnclosedAmbientTypes; var ambientEnclosedTypes = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(publicAmbientEnclosedTypesTable, new TypeScript.StringHashTable())); var publicMembers = typeSymbol.type.members.publicMembers; var publicMembersTable = (publicMembers == null) ? new TypeScript.StringHashTable() : publicMembers; var members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(publicMembersTable, new TypeScript.StringHashTable())); var publicAmbientMembers = typeSymbol.type.ambientMembers.publicMembers; var publicAmbientMembersTable = (publicAmbientMembers == null) ? new TypeScript.StringHashTable() : publicAmbientMembers; var ambientMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(publicAmbientMembersTable, new TypeScript.StringHashTable())); modType = new TypeScript.ModuleType(enclosedTypes, ambientEnclosedTypes); if(isEnum) { modType.typeFlags |= TypeScript.TypeFlags.IsEnum; } modType.members = members; modType.ambientMembers = ambientMembers; modType.setHasImplementation(); modType.symbol = typeSymbol; typeSymbol.addLocation(moduleDecl.minChar); typeSymbol.expansions.push(modType); typeSymbol.expansionsDeclAST.push(moduleDecl); } if(context.scopeChain.moduleDecl) { context.scopeChain.moduleDecl.recordNonInterface(); } if(isExported) { typeSymbol.flags |= TypeScript.SymbolFlags.Exported; } if((context.scopeChain.moduleDecl) || (context.scopeChain.container == context.checker.gloMod)) { typeSymbol.flags |= TypeScript.SymbolFlags.ModuleMember; } moduleDecl.mod = modType; TypeScript.pushTypeCollectionScope(typeSymbol, modType.members, modType.ambientMembers, modType.enclosedTypes, modType.ambientEnclosedTypes, context, null, null, moduleDecl); return true; } TypeScript.preCollectModuleTypes = preCollectModuleTypes; function preCollectClassTypes(ast, parent, context) { var scopeChain = context.scopeChain; var classDecl = ast; var classType; var instanceType; var typeSymbol = null; var className = (classDecl.name).text; var alreadyInScope = false; var isAmbient = TypeScript.hasFlag(classDecl.varFlags, TypeScript.VarFlags.Ambient); var isExported = TypeScript.hasFlag(classDecl.varFlags, TypeScript.VarFlags.Exported); var isGlobal = context.scopeChain.container == context.checker.gloMod; var containerMod = scopeChain.container; var foundValSymbol = false; typeSymbol = scopeChain.scope.findLocal(className, false, true); if(!typeSymbol) { var valTypeSymbol = scopeChain.scope.findLocal(className, false, false); if(valTypeSymbol && valTypeSymbol.isType() && valTypeSymbol.declAST && valTypeSymbol.declAST.nodeType == TypeScript.NodeType.FuncDecl && (valTypeSymbol.declAST).isSignature()) { typeSymbol = valTypeSymbol; foundValSymbol = true; if(isExported) { typeSymbol.flags |= TypeScript.SymbolFlags.Exported; } if(isAmbient) { typeSymbol.flags |= TypeScript.SymbolFlags.Ambient; } context.scopeChain.scope.enter(context.scopeChain.container, ast, typeSymbol, context.checker.errorReporter, isExported || isGlobal, true, isAmbient); } } if(typeSymbol && !foundValSymbol && (typeSymbol.declAST != classDecl)) { typeSymbol = null; } if(typeSymbol == null) { var valueSymbol = scopeChain.scope.findLocal(className, false, false); classType = new TypeScript.Type(); classType.setHasImplementation(); instanceType = new TypeScript.Type(); instanceType.setHasImplementation(); classType.instanceType = instanceType; classType.members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); classType.ambientMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); addPrototypeField(classType, classDecl, context); instanceType.members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); instanceType.ambientMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); typeSymbol = new TypeScript.TypeSymbol(className, classDecl.name.minChar, className.length, context.checker.locationInfo.unitIndex, classType); typeSymbol.declAST = classDecl; typeSymbol.instanceType = instanceType; classType.symbol = typeSymbol; instanceType.symbol = typeSymbol; if(context.scopeChain.moduleDecl) { context.scopeChain.moduleDecl.recordNonInterface(); typeSymbol.declModule = context.scopeChain.moduleDecl; typeSymbol.flags |= TypeScript.SymbolFlags.ModuleMember; } if(isExported) { typeSymbol.flags |= TypeScript.SymbolFlags.Exported; } if(isAmbient) { typeSymbol.flags |= TypeScript.SymbolFlags.Ambient; } ast.type = classType; context.scopeChain.scope.enter(context.scopeChain.container, ast, typeSymbol, context.checker.errorReporter, isExported || isGlobal, true, isAmbient); if(valueSymbol == null) { context.scopeChain.scope.enter(context.scopeChain.container, ast, typeSymbol, context.checker.errorReporter, isExported || isGlobal, false, isAmbient); } } else { classType = typeSymbol.type; if(classType.instanceType == null) { classType.instanceType = new TypeScript.Type(); classType.instanceType.setHasImplementation(); classType.instanceType.members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); classType.instanceType.symbol = classType.symbol; classType.members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); classType.ambientMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); } instanceType = classType.instanceType; ast.type = classType; } if(!classDecl.constructorDecl) { if(typeSymbol && typeSymbol.declAST && typeSymbol.declAST.type && typeSymbol.declAST.type.call && !(typeSymbol.declAST).isOverload) { context.checker.errorReporter.duplicateIdentifier(typeSymbol.declAST, typeSymbol.name); } createNewConstructGroupForType(classDecl.type); } classType.typeFlags |= TypeScript.TypeFlags.IsClass; instanceType.typeFlags |= TypeScript.TypeFlags.IsClass; getBases(instanceType, classDecl); TypeScript.pushTypeCollectionScope(typeSymbol, instanceType.members, instanceType.ambientMembers, null, null, context, instanceType, classType, null); return true; } TypeScript.preCollectClassTypes = preCollectClassTypes; function preCollectInterfaceTypes(ast, parent, context) { var scopeChain = context.scopeChain; var interfaceDecl = ast; var interfaceSymbol = null; var interfaceType = null; var isExported = TypeScript.hasFlag(interfaceDecl.varFlags, TypeScript.VarFlags.Exported); var isGlobal = context.scopeChain.container == context.checker.gloMod; var alreadyInScope = true; alreadyInScope = false; var interfaceName = (interfaceDecl.name).text; interfaceSymbol = scopeChain.scope.findLocal(interfaceName, false, true); if(interfaceSymbol == null) { interfaceType = new TypeScript.Type(); interfaceSymbol = new TypeScript.TypeSymbol(interfaceName, interfaceDecl.name.minChar, interfaceName.length, context.checker.locationInfo.unitIndex, interfaceType); interfaceType.symbol = interfaceSymbol; interfaceType.members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); interfaceType.ambientMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); interfaceSymbol.declAST = interfaceDecl; interfaceSymbol.declModule = context.scopeChain.moduleDecl; } else { alreadyInScope = true; interfaceType = interfaceSymbol.type; } if(!interfaceType) { interfaceType = context.checker.anyType; } ast.type = interfaceType; getBases(interfaceType, interfaceDecl); if(isExported) { interfaceSymbol.flags |= TypeScript.SymbolFlags.Exported; } if(context.scopeChain.moduleDecl) { interfaceSymbol.flags |= TypeScript.SymbolFlags.ModuleMember; } if(!alreadyInScope) { context.scopeChain.scope.enter(context.scopeChain.container, ast, interfaceSymbol, context.checker.errorReporter, isGlobal || isExported, true, false); } TypeScript.pushTypeCollectionScope(interfaceSymbol, interfaceType.members, interfaceType.ambientMembers, null, null, context, interfaceType, null, null); return true; } TypeScript.preCollectInterfaceTypes = preCollectInterfaceTypes; function preCollectArgDeclTypes(ast, parent, context) { var scopeChain = context.scopeChain; var argDecl = ast; if(TypeScript.hasFlag(argDecl.varFlags, TypeScript.VarFlags.Public | TypeScript.VarFlags.Private)) { var field = new TypeScript.ValueLocation(); var isPrivate = TypeScript.hasFlag(argDecl.varFlags, TypeScript.VarFlags.Private); var fieldSymbol = new TypeScript.FieldSymbol(argDecl.id.text, argDecl.id.minChar, context.checker.locationInfo.unitIndex, !TypeScript.hasFlag(argDecl.varFlags, TypeScript.VarFlags.Readonly), field); fieldSymbol.transferVarFlags(argDecl.varFlags); field.symbol = fieldSymbol; fieldSymbol.declAST = ast; argDecl.parameterPropertySym = fieldSymbol; context.scopeChain.scope.enter(context.scopeChain.container, ast, fieldSymbol, context.checker.errorReporter, !isPrivate, false, false); field.typeLink = TypeScript.getTypeLink(argDecl.typeExpr, context.checker, argDecl.init == null); argDecl.sym = fieldSymbol; } return false; } TypeScript.preCollectArgDeclTypes = preCollectArgDeclTypes; function preCollectVarDeclTypes(ast, parent, context) { var scopeChain = context.scopeChain; var varDecl = ast; var isAmbient = TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Ambient); var isExported = TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Exported); var isGlobal = context.scopeChain.container == context.checker.gloMod; var isProperty = TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Property); var isStatic = TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Static); var isPrivate = TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Private); var isOptional = TypeScript.hasFlag(varDecl.id.flags, TypeScript.ASTFlags.OptionalName); if(context.scopeChain.moduleDecl) { context.scopeChain.moduleDecl.recordNonInterface(); } if(isProperty || isExported || (context.scopeChain.container == context.checker.gloMod) || context.scopeChain.moduleDecl) { if(isAmbient) { var existingSym = scopeChain.scope.findLocal(varDecl.id.text, false, false); if(existingSym) { varDecl.sym = existingSym; return false; } } if(varDecl.id == null) { context.checker.errorReporter.simpleError(varDecl, "Expected variable identifier at this location"); return false; } var field = new TypeScript.ValueLocation(); var fieldSymbol = new TypeScript.FieldSymbol(varDecl.id.text, varDecl.id.minChar, context.checker.locationInfo.unitIndex, (varDecl.varFlags & TypeScript.VarFlags.Readonly) == TypeScript.VarFlags.None, field); fieldSymbol.transferVarFlags(varDecl.varFlags); if(isOptional) { fieldSymbol.flags |= TypeScript.SymbolFlags.Optional; } field.symbol = fieldSymbol; fieldSymbol.declAST = ast; if((context.scopeChain.moduleDecl) || (context.scopeChain.container == context.checker.gloMod)) { fieldSymbol.flags |= TypeScript.SymbolFlags.ModuleMember; fieldSymbol.declModule = context.scopeChain.moduleDecl; } if(TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Property) && isStatic && context.scopeChain.classType) { if(!context.scopeChain.classType.members.publicMembers.add(varDecl.id.text, fieldSymbol)) { context.checker.errorReporter.duplicateIdentifier(ast, fieldSymbol.name); } fieldSymbol.container = context.scopeChain.classType.symbol; } else { context.scopeChain.scope.enter(context.scopeChain.container, ast, fieldSymbol, context.checker.errorReporter, !isPrivate && (isProperty || isExported || isGlobal || isStatic), false, isAmbient); } if(TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Exported)) { fieldSymbol.flags |= TypeScript.SymbolFlags.Exported; } field.typeLink = TypeScript.getTypeLink(varDecl.typeExpr, context.checker, varDecl.init == null); varDecl.sym = fieldSymbol; } return false; } TypeScript.preCollectVarDeclTypes = preCollectVarDeclTypes; function preCollectFuncDeclTypes(ast, parent, context) { var scopeChain = context.scopeChain; if(context.scopeChain.moduleDecl) { context.scopeChain.moduleDecl.recordNonInterface(); } var funcDecl = ast; var fgSym = null; var nameText = funcDecl.getNameText(); var isExported = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Exported | TypeScript.FncFlags.ClassPropertyMethodExported); var isStatic = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Static); var isPrivate = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Private); var isConstructor = funcDecl.isConstructMember() || funcDecl.isConstructor; var containerSym = (((funcDecl.isMethod() && isStatic) || funcDecl.isAccessor()) && context.scopeChain.classType ? context.scopeChain.classType.symbol : context.scopeChain.container); var containerScope = context.scopeChain.scope; var isGlobal = containerSym == context.checker.gloMod; var isOptional = funcDecl.name && TypeScript.hasFlag(funcDecl.name.flags, TypeScript.ASTFlags.OptionalName); var go = false; var foundSymbol = false; if(isConstructor && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod)) { containerSym = containerSym.container; containerScope = scopeChain.previous.scope; } funcDecl.unitIndex = context.checker.locationInfo.unitIndex; if(!funcDecl.isConstructor && containerSym && containerSym.declAST && containerSym.declAST.nodeType == TypeScript.NodeType.FuncDecl && (containerSym.declAST).isConstructor && !funcDecl.isMethod()) { return go; } if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Signature)) { var instType = context.scopeChain.thisType; if(nameText && nameText != "__missing") { if(isStatic) { fgSym = containerSym.type.members.allMembers.lookup(nameText); } else { fgSym = containerScope.findLocal(nameText, false, false); if(fgSym == null) { fgSym = containerScope.findLocal(nameText, false, true); } } if(fgSym) { foundSymbol = true; if(!funcDecl.isSignature() && (TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Ambient) != TypeScript.hasFlag(fgSym.flags, TypeScript.SymbolFlags.Ambient))) { fgSym = null; } } } if(fgSym == null) { if(!(funcDecl.isSpecialFn())) { fgSym = context.checker.createFunctionSignature(funcDecl, containerSym, containerScope, null, !foundSymbol).declAST.type.symbol; } else { fgSym = context.checker.createFunctionSignature(funcDecl, containerSym, containerScope, containerSym, false).declAST.type.symbol; } if(fgSym.declAST == null || !funcDecl.isSpecialFn()) { fgSym.declAST = ast; } } else { if((fgSym.kind() == TypeScript.SymbolKind.Type)) { fgSym = context.checker.createFunctionSignature(funcDecl, containerSym, containerScope, fgSym, false).declAST.type.symbol; } else { context.checker.errorReporter.simpleError(funcDecl, "Function or method '" + funcDecl.name.actualText + "' already declared as a property"); } } if(funcDecl.isSpecialFn() && !isStatic) { funcDecl.type = instType ? instType : fgSym.type; } else { funcDecl.type = fgSym.type; } } else { if(nameText) { if(isStatic) { fgSym = containerSym.type.members.allMembers.lookup(nameText); } else { if(funcDecl.isConstructor && context.scopeChain.previous) { fgSym = context.scopeChain.previous.scope.findLocal(nameText, false, false); } if(fgSym == null) { fgSym = containerScope.findLocal(nameText, false, false); } } if(fgSym) { foundSymbol = true; if(!isConstructor && fgSym.declAST.nodeType == TypeScript.NodeType.FuncDecl && !(fgSym.declAST).isAccessor() && !(fgSym.declAST).isSignature()) { fgSym = null; foundSymbol = false; } } } if(fgSym && !fgSym.isAccessor() && fgSym.type && fgSym.type.construct && fgSym.type.construct.signatures != [] && (fgSym.type.construct.signatures[0].declAST == null || !TypeScript.hasFlag(fgSym.type.construct.signatures[0].declAST.fncFlags, TypeScript.FncFlags.Ambient)) && !funcDecl.isConstructor) { context.checker.errorReporter.simpleError(funcDecl, "Functions may not have class overloads"); } if(fgSym && !(fgSym.kind() == TypeScript.SymbolKind.Type) && funcDecl.isMethod() && !funcDecl.isAccessor() && !funcDecl.isConstructor) { context.checker.errorReporter.simpleError(funcDecl, "Function or method '" + funcDecl.name.actualText + "' already declared as a property"); fgSym.type = context.checker.anyType; } var sig = context.checker.createFunctionSignature(funcDecl, containerSym, containerScope, fgSym, !foundSymbol); if(((!fgSym || fgSym.declAST.nodeType != TypeScript.NodeType.FuncDecl) && funcDecl.isAccessor()) || (fgSym && fgSym.isAccessor())) { funcDecl.accessorSymbol = context.checker.createAccessorSymbol(funcDecl, fgSym, containerSym.type, (funcDecl.isMethod() && isStatic), true, containerScope, containerSym); } funcDecl.type.symbol.declAST = ast; if(funcDecl.isConstructor) { go = true; } ; ; } if(isExported) { if(funcDecl.type.call) { funcDecl.type.symbol.flags |= TypeScript.SymbolFlags.Exported; } if(fgSym && !fgSym.isAccessor() && fgSym.kind() == TypeScript.SymbolKind.Type && fgSym.type.call) { fgSym.flags |= TypeScript.SymbolFlags.Exported; } } if(context.scopeChain.moduleDecl && !funcDecl.isSpecialFn()) { funcDecl.type.symbol.flags |= TypeScript.SymbolFlags.ModuleMember; funcDecl.type.symbol.declModule = context.scopeChain.moduleDecl; } if(fgSym && isOptional) { fgSym.flags |= TypeScript.SymbolFlags.Optional; } return go; } TypeScript.preCollectFuncDeclTypes = preCollectFuncDeclTypes; function preCollectTypes(ast, parent, walker) { var context = walker.state; var go = false; var scopeChain = context.scopeChain; if(ast.nodeType == TypeScript.NodeType.Script) { var script = ast; context.script = script; go = true; } else { if(ast.nodeType == TypeScript.NodeType.List) { go = true; } else { if(ast.nodeType == TypeScript.NodeType.ImportDeclaration) { go = preCollectImportTypes(ast, parent, context); } else { if(ast.nodeType == TypeScript.NodeType.With) { go = false; } else { if(ast.nodeType == TypeScript.NodeType.ModuleDeclaration) { go = preCollectModuleTypes(ast, parent, context); } else { if(ast.nodeType == TypeScript.NodeType.ClassDeclaration) { go = preCollectClassTypes(ast, parent, context); } else { if(ast.nodeType == TypeScript.NodeType.Block) { go = true; } else { if(ast.nodeType == TypeScript.NodeType.InterfaceDeclaration) { go = preCollectInterfaceTypes(ast, parent, context); } else { if(ast.nodeType == TypeScript.NodeType.ArgDecl) { go = preCollectArgDeclTypes(ast, parent, context); } else { if(ast.nodeType == TypeScript.NodeType.VarDecl) { go = preCollectVarDeclTypes(ast, parent, context); } else { if(ast.nodeType == TypeScript.NodeType.FuncDecl) { go = preCollectFuncDeclTypes(ast, parent, context); } else { if(ast.isStatementOrExpression() && context.scopeChain.moduleDecl) { context.scopeChain.moduleDecl.recordNonInterface(); } } } } } } } } } } } } walker.options.goChildren = go; return ast; } TypeScript.preCollectTypes = preCollectTypes; function postCollectTypes(ast, parent, walker) { var context = walker.state; if(ast.nodeType == TypeScript.NodeType.ModuleDeclaration) { TypeScript.popTypeCollectionScope(context); } else { if(ast.nodeType == TypeScript.NodeType.ClassDeclaration) { TypeScript.popTypeCollectionScope(context); } else { if(ast.nodeType == TypeScript.NodeType.InterfaceDeclaration) { TypeScript.popTypeCollectionScope(context); } } } return ast; } TypeScript.postCollectTypes = postCollectTypes; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var ScopeChain = (function () { function ScopeChain(container, previous, scope) { this.container = container; this.previous = previous; this.scope = scope; } return ScopeChain; })(); TypeScript.ScopeChain = ScopeChain; var BBUseDefInfo = (function () { function BBUseDefInfo(bb) { this.bb = bb; this.defsBySymbol = new Array(); this.useIndexBySymbol = new Array(); } BBUseDefInfo.prototype.updateTop = function () { var temp = new BitVector(this.top.bitCount); for(var i = 0, succLen = this.bb.successors.length; i < succLen; i++) { var succ = this.bb.successors[i]; if(succ.useDef) { temp.union(succ.useDef.top); } } temp.difference(this.kill); temp.union(this.gen); var changed = temp.notEq(this.top); this.top = temp; return changed; }; BBUseDefInfo.prototype.initialize = function (useDefContext) { var _this = this; var defSym = function (sym, context) { if(context.isLocalSym(sym)) { var index = context.getSymbolIndex(sym); _this.useIndexBySymbol[index] = new Array(); _this.defsBySymbol[index] = true; } }; var useSym = function (sym, context, ast) { if(context.isLocalSym(sym)) { var symIndex = context.getSymbolIndex(sym); if(_this.useIndexBySymbol[symIndex] == undefined) { _this.useIndexBySymbol[symIndex] = new Array(); } var symUses = _this.useIndexBySymbol[symIndex]; var astIndex = context.getUseIndex(ast); context.addUse(symIndex, astIndex); symUses.push(astIndex); } }; function initUseDefPre(cur, parent, walker) { var context = walker.state; if(cur == null) { cur = null; } if(cur.nodeType == TypeScript.NodeType.VarDecl) { var varDecl = cur; if(varDecl.init || TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.AutoInit)) { defSym(varDecl.sym, context); } } else { if(cur.nodeType == TypeScript.NodeType.Name) { if(parent) { if(parent.nodeType == TypeScript.NodeType.Asg) { var asg = parent; if(asg.operand1 == cur) { return cur; } } else { if(parent.nodeType == TypeScript.NodeType.VarDecl) { var parentDecl = parent; if(parentDecl.id == cur) { return cur; } } } } var id = cur; useSym(id.sym, context, cur); } else { if((cur.nodeType >= TypeScript.NodeType.Asg) && (cur.nodeType <= TypeScript.NodeType.LastAsg)) { var asg = cur; if(asg.operand1 && (asg.operand1.nodeType == TypeScript.NodeType.Name)) { var id = asg.operand1; defSym(id.sym, context); } } else { if(cur.nodeType == TypeScript.NodeType.FuncDecl) { walker.options.goChildren = false; } } } } return cur; } var options = new TypeScript.AstWalkOptions(); options.reverseSiblings = true; TypeScript.getAstWalkerFactory().walk(this.bb.content, initUseDefPre, null, options, useDefContext); }; BBUseDefInfo.prototype.initializeGen = function (useDefContext) { var symbolLen = this.useIndexBySymbol.length; var bitCount = useDefContext.uses.length; this.gen = new BitVector(bitCount); for(var s = 0; s < symbolLen; s++) { var symUses = this.useIndexBySymbol[s]; if((symUses != undefined) && (symUses.length > 0)) { for(var u = 0, uLen = symUses.length; u < uLen; u++) { this.gen.set(symUses[u], true); } } } this.top = this.gen; }; BBUseDefInfo.prototype.initializeKill = function (useDefContext) { this.kill = new BitVector(this.gen.bitCount); for(var s = 0, symbolLen = this.defsBySymbol.length; s < symbolLen; s++) { if(this.defsBySymbol[s]) { var globalSymUses = useDefContext.useIndexBySymbol[s]; if(globalSymUses) { for(var u = 0, useLen = globalSymUses.length; u < useLen; u++) { this.kill.set(globalSymUses[u], true); } } } } }; return BBUseDefInfo; })(); TypeScript.BBUseDefInfo = BBUseDefInfo; var UseDefContext = (function () { function UseDefContext() { this.useIndexBySymbol = new Array(); this.uses = new Array(); this.symbols = new Array(); this.symbolMap = new TypeScript.StringHashTable(); this.symbolCount = 0; } UseDefContext.prototype.getSymbolIndex = function (sym) { var name = sym.name; var index = (this.symbolMap.lookup(name)); if(index == null) { index = this.symbolCount++; this.symbols[index] = sym; this.symbolMap.add(name, index); } return index; }; UseDefContext.prototype.addUse = function (symIndex, astIndex) { var useBySym = this.useIndexBySymbol[symIndex]; if(useBySym == undefined) { useBySym = new Array(); this.useIndexBySymbol[symIndex] = useBySym; } useBySym[useBySym.length] = astIndex; }; UseDefContext.prototype.getUseIndex = function (ast) { this.uses[this.uses.length] = ast; return this.uses.length - 1; }; UseDefContext.prototype.isLocalSym = function (sym) { return (sym && (sym.container == this.func) && (sym.kind() == TypeScript.SymbolKind.Variable)); }; UseDefContext.prototype.killSymbol = function (sym, bbUses) { var index = this.symbolMap.lookup(sym.name); var usesOfSym = this.useIndexBySymbol[index]; for(var k = 0, len = usesOfSym.length; k < len; k++) { bbUses.set(usesOfSym[k], true); } }; return UseDefContext; })(); TypeScript.UseDefContext = UseDefContext; var BitVector = (function () { function BitVector(bitCount) { this.bitCount = bitCount; this.firstBits = 0; this.restOfBits = null; if(this.bitCount > BitVector.packBits) { this.restOfBits = new Array(); var len = Math.floor(this.bitCount / BitVector.packBits); for(var i = 0; i < len; i++) { this.restOfBits[i] = 0; } } } BitVector.packBits = 30; BitVector.prototype.set = function (bitIndex, value) { if(bitIndex < BitVector.packBits) { if(value) { this.firstBits |= (1 << bitIndex); } else { this.firstBits &= (~(1 << bitIndex)); } } else { var offset = Math.floor(bitIndex / BitVector.packBits) - 1; var localIndex = bitIndex % BitVector.packBits; if(value) { this.restOfBits[offset] |= (1 << localIndex); } else { this.restOfBits[offset] &= (~(1 << localIndex)); } } }; BitVector.prototype.map = function (fn) { var k; for(k = 0; k < BitVector.packBits; k++) { if(k == this.bitCount) { return; } if(((1 << k) & this.firstBits) != 0) { fn(k); } } if(this.restOfBits) { var len; var cumu = BitVector.packBits; for(k = 0 , len = this.restOfBits.length; k < len; k++) { var myBits = this.restOfBits[k]; for(var j = 0; j < BitVector.packBits; j++) { if(((1 << j) & myBits) != 0) { fn(cumu); } cumu++; if(cumu == this.bitCount) { return; } } } } }; BitVector.prototype.union = function (b) { this.firstBits |= b.firstBits; if(this.restOfBits) { for(var k = 0, len = this.restOfBits.length; k < len; k++) { var myBits = this.restOfBits[k]; var bBits = b.restOfBits[k]; this.restOfBits[k] = myBits | bBits; } } }; BitVector.prototype.intersection = function (b) { this.firstBits &= b.firstBits; if(this.restOfBits) { for(var k = 0, len = this.restOfBits.length; k < len; k++) { var myBits = this.restOfBits[k]; var bBits = b.restOfBits[k]; this.restOfBits[k] = myBits & bBits; } } }; BitVector.prototype.notEq = function (b) { if(this.firstBits != b.firstBits) { return true; } if(this.restOfBits) { for(var k = 0, len = this.restOfBits.length; k < len; k++) { var myBits = this.restOfBits[k]; var bBits = b.restOfBits[k]; if(myBits != bBits) { return true; } } } return false; }; BitVector.prototype.difference = function (b) { var oldFirstBits = this.firstBits; this.firstBits &= (~b.firstBits); if(this.restOfBits) { for(var k = 0, len = this.restOfBits.length; k < len; k++) { var myBits = this.restOfBits[k]; var bBits = b.restOfBits[k]; this.restOfBits[k] &= (~bBits); } } }; return BitVector; })(); TypeScript.BitVector = BitVector; var BasicBlock = (function () { function BasicBlock() { this.predecessors = new Array(); this.index = -1; this.markValue = 0; this.successors = new Array(); this.useDef = null; this.content = new TypeScript.ASTList(); } BasicBlock.prototype.marked = function (markBase) { return this.markValue > markBase; }; BasicBlock.prototype.mark = function () { this.markValue++; }; BasicBlock.prototype.addSuccessor = function (successor) { this.successors[this.successors.length] = successor; successor.predecessors[successor.predecessors.length] = this; }; return BasicBlock; })(); TypeScript.BasicBlock = BasicBlock; var ControlFlowContext = (function () { function ControlFlowContext(current, exit) { this.current = current; this.exit = exit; this.entry = null; this.unreachable = null; this.noContinuation = false; this.statementStack = new Array(); this.currentSwitch = new Array(); this.markBase = 0; this.linearBBs = new Array(); this.entry = this.current; } ControlFlowContext.prototype.walk = function (ast, parent) { return this.walker.walk(ast, parent); }; ControlFlowContext.prototype.pushSwitch = function (bb) { this.currentSwitch.push(bb); }; ControlFlowContext.prototype.popSwitch = function () { return this.currentSwitch.pop(); }; ControlFlowContext.prototype.reportUnreachable = function (er) { if(this.unreachable && (this.unreachable.length > 0)) { var len = this.unreachable.length; for(var i = 0; i < len; i++) { var unreachableAST = this.unreachable[i]; if(unreachableAST.nodeType != TypeScript.NodeType.EndCode) { er.simpleError(unreachableAST, "unreachable code"); } } } }; ControlFlowContext.prototype.printAST = function (ast, outfile) { var printContext = new TypeScript.PrintContext(outfile, null); printContext.increaseIndent(); TypeScript.getAstWalkerFactory().walk(ast, TypeScript.prePrintAST, TypeScript.postPrintAST, null, printContext); printContext.decreaseIndent(); }; ControlFlowContext.prototype.printBlockContent = function (bb, outfile) { var content = bb.content; for(var i = 0, len = content.members.length; i < len; i++) { var ast = content.members[i]; this.printAST(ast, outfile); } }; ControlFlowContext.prototype.bfs = function (nodeFunc, edgeFunc, preEdges, postEdges) { var markValue = this.markBase++; var q = new Array(); q[q.length] = this.entry; while(q.length > 0) { var bb = q.pop(); if(!(bb.marked(markValue))) { bb.mark(); if(nodeFunc) { nodeFunc(bb); } var succLen = bb.successors.length; if(succLen > 0) { if(preEdges) { preEdges(); } for(var j = succLen - 1; j >= 0; j--) { var successor = bb.successors[j]; if(!(successor.marked(this.markBase))) { if(edgeFunc) { edgeFunc(bb, successor); } q[q.length] = successor; } } if(postEdges) { postEdges(); } } } } }; ControlFlowContext.prototype.useDef = function (er, funcSym) { var _this = this; var useDefContext = new UseDefContext(); useDefContext.func = funcSym; var useDefInit = function (bb) { bb.useDef = new BBUseDefInfo(bb); bb.useDef.initialize(useDefContext); _this.linearBBs[_this.linearBBs.length] = bb; }; this.bfs(useDefInit, null, null, null); var i, bbLen; for(i = 0 , bbLen = this.linearBBs.length; i < bbLen; i++) { this.linearBBs[i].useDef.initializeGen(useDefContext); this.linearBBs[i].useDef.initializeKill(useDefContext); } var changed = true; while(changed) { changed = false; for(i = 0; i < bbLen; i++) { changed = this.linearBBs[i].useDef.updateTop() || changed; } } var top = this.entry.useDef.top; top.map(function (index) { var ast = useDefContext.uses[index]; er.simpleError(ast, "use of variable '" + ast.actualText + "' that is not definitely assigned"); }); }; ControlFlowContext.prototype.print = function (outfile) { var _this = this; var index = 0; var node = function (bb) { if(bb.index < 0) { bb.index = index++; } if(bb == _this.exit) { outfile.WriteLine("Exit block with index " + bb.index); } else { outfile.WriteLine("Basic block with index " + bb.index); _this.printBlockContent(bb, outfile); } }; function preEdges() { outfile.Write(" Branches to "); } function postEdges() { outfile.WriteLine(""); } function edge(node1, node2) { if(node2.index < 0) { node2.index = index++; } outfile.Write(node2.index + " "); } this.bfs(node, edge, preEdges, postEdges); if(this.unreachable != null) { for(var i = 0, len = this.unreachable.length; i < len; i++) { outfile.WriteLine("Unreachable basic block ..."); this.printAST(this.unreachable[i], outfile); } } }; ControlFlowContext.prototype.pushStatement = function (stmt, continueBB, breakBB) { this.statementStack.push({ stmt: stmt, continueBB: continueBB, breakBB: breakBB }); }; ControlFlowContext.prototype.popStatement = function () { return this.statementStack.pop(); }; ControlFlowContext.prototype.returnStmt = function () { this.current.addSuccessor(this.exit); this.setUnreachable(); }; ControlFlowContext.prototype.setUnreachable = function () { this.current = null; this.noContinuation = true; }; ControlFlowContext.prototype.addUnreachable = function (ast) { if(this.unreachable === null) { this.unreachable = new Array(); } this.unreachable[this.unreachable.length] = ast; }; ControlFlowContext.prototype.unconditionalBranch = function (target, isContinue) { var targetBB = null; for(var i = 0, len = this.statementStack.length; i < len; i++) { var targetInfo = this.statementStack[i]; if(targetInfo.stmt == target) { if(isContinue) { targetBB = targetInfo.continueBB; } else { targetBB = targetInfo.breakBB; } break; } } if(targetBB) { this.current.addSuccessor(targetBB); } this.setUnreachable(); }; ControlFlowContext.prototype.addContent = function (ast) { if(this.current) { this.current.content.append(ast); } }; return ControlFlowContext; })(); TypeScript.ControlFlowContext = ControlFlowContext; var ResolutionDataCache = (function () { function ResolutionDataCache() { this.cacheSize = 16; this.rdCache = []; this.nextUp = 0; for(var i = 0; i < this.cacheSize; i++) { this.rdCache[i] = { actuals: new Array(), exactCandidates: new Array(), conversionCandidates: new Array(), id: i }; } } ResolutionDataCache.prototype.getResolutionData = function () { var rd = null; if(this.nextUp < this.cacheSize) { rd = this.rdCache[this.nextUp]; } if(rd == null) { this.cacheSize++; rd = { actuals: new Array(), exactCandidates: new Array(), conversionCandidates: new Array(), id: this.cacheSize }; this.rdCache[this.cacheSize] = rd; } this.nextUp++; return rd; }; ResolutionDataCache.prototype.returnResolutionData = function (rd) { rd.actuals.length = 0; rd.exactCandidates.length = 0; rd.conversionCandidates.length = 0; this.nextUp = rd.id; }; return ResolutionDataCache; })(); TypeScript.ResolutionDataCache = ResolutionDataCache; var TypeFlow = (function () { function TypeFlow(logger, initScope, parser, checker) { this.logger = logger; this.initScope = initScope; this.parser = parser; this.checker = checker; this.thisFnc = null; this.thisClassNode = null; this.enclosingFncIsMethod = false; this.arrayInterfaceType = null; this.stringInterfaceType = null; this.objectInterfaceType = null; this.functionInterfaceType = null; this.numberInterfaceType = null; this.booleanInterfaceType = null; this.iargumentsInterfaceType = null; this.currentScript = null; this.inImportTypeCheck = false; this.inTypeRefTypeCheck = false; this.inArrayElementTypeCheck = false; this.resolutionDataCache = new ResolutionDataCache(); this.nestingLevel = 0; this.inSuperCall = false; this.checker.typeFlow = this; this.scope = this.initScope; this.globalScope = this.initScope; this.doubleType = this.checker.numberType; this.booleanType = this.checker.booleanType; this.stringType = this.checker.stringType; this.anyType = this.checker.anyType; this.regexType = this.anyType; this.nullType = this.checker.nullType; this.voidType = this.checker.voidType; this.arrayAnyType = this.checker.makeArrayType(this.anyType); } TypeFlow.prototype.initLibs = function () { var arraySym = this.globalScope.find("Array", false, true); if(arraySym && (arraySym.kind() == TypeScript.SymbolKind.Type)) { this.arrayInterfaceType = (arraySym).type; } var stringSym = this.globalScope.find("String", false, true); if(stringSym && (stringSym.kind() == TypeScript.SymbolKind.Type)) { this.stringInterfaceType = (stringSym).type; } var objectSym = this.globalScope.find("Object", false, true); if(objectSym && (objectSym.kind() == TypeScript.SymbolKind.Type)) { this.objectInterfaceType = (objectSym).type; } var fnSym = this.globalScope.find("Function", false, true); if(fnSym && (fnSym.kind() == TypeScript.SymbolKind.Type)) { this.functionInterfaceType = (fnSym).type; } var numberSym = this.globalScope.find("Number", false, true); if(numberSym && (numberSym.kind() == TypeScript.SymbolKind.Type)) { this.numberInterfaceType = (numberSym).type; } var booleanSym = this.globalScope.find("Boolean", false, true); if(booleanSym && (booleanSym.kind() == TypeScript.SymbolKind.Type)) { this.booleanInterfaceType = (booleanSym).type; } var regexSym = this.globalScope.find("RegExp", false, true); if(regexSym && (regexSym.kind() == TypeScript.SymbolKind.Type)) { this.regexType = (regexSym).type; } }; TypeFlow.prototype.cast = function (ast, type) { return this.castWithCoercion(ast, type, true, false); }; TypeFlow.prototype.castWithCoercion = function (ast, type, applyCoercion, typeAssertion) { var comparisonInfo = new TypeScript.TypeComparisonInfo(); if(this.checker.sourceIsAssignableToTarget(ast.type, type, comparisonInfo) || (typeAssertion && this.checker.sourceIsAssignableToTarget(type, ast.type, comparisonInfo))) { if(applyCoercion) { if(type == null) { ast.type = this.anyType; } else { if(type.isClass()) { ast.type = type.instanceType; } else { ast.type = type; } } } return ast; } else { this.checker.errorReporter.incompatibleTypes(ast, ast.type, type, null, this.scope, comparisonInfo); return ast; } }; TypeFlow.prototype.inScopeTypeCheck = function (ast, enclosingScope) { var prevScope = this.scope; this.scope = enclosingScope; var svThisFnc = this.thisFnc; var svThisType = this.thisType; var svThisClassNode = this.thisClassNode; var svCurrentModDecl = this.checker.currentModDecl; var prevMethodStatus = this.enclosingFncIsMethod; var container = this.scope.container; var fnc = null; while(container) { if(container.kind() == TypeScript.SymbolKind.Type) { var typeSym = container; var type = typeSym.type; if(type.call) { if(fnc == null) { this.enclosingFncIsMethod = typeSym.isMethod; fnc = container.declAST; } } if(type.isClass()) { this.thisType = type.instanceType; if(typeSym.declAST && (typeSym.declAST.nodeType == TypeScript.NodeType.ClassDeclaration)) { this.thisClassNode = typeSym.declAST; } break; } if(type.isModuleType()) { this.checker.currentModDecl = typeSym.declAST; break; } } container = container.container; } this.thisFnc = fnc; var updated = this.typeCheck(ast); this.thisFnc = svThisFnc; this.thisType = svThisType; this.thisClassNode = svThisClassNode; this.checker.currentModDecl = svCurrentModDecl; this.enclosingFncIsMethod = prevMethodStatus; this.scope = prevScope; return updated; }; TypeFlow.prototype.typeCheck = function (ast) { if(ast) { return ast.typeCheck(this); } else { return null; } }; TypeFlow.prototype.inScopeTypeCheckDecl = function (ast) { if(ast.nodeType == TypeScript.NodeType.VarDecl || ast.nodeType == TypeScript.NodeType.ArgDecl) { this.inScopeTypeCheckBoundDecl(ast); } else { if(ast.nodeType == TypeScript.NodeType.FuncDecl) { var funcDecl = ast; if(funcDecl.isAccessor()) { this.typeCheckFunction(funcDecl); } } } }; TypeFlow.prototype.inScopeTypeCheckBoundDecl = function (varDecl) { var sym = varDecl.sym; var svThisFnc = this.thisFnc; var svThisType = this.thisType; var prevMethodStatus = this.enclosingFncIsMethod; var prevLocationInfo = this.checker.locationInfo; if(sym && sym.container) { var instanceScope = TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.ClassConstructorProperty) ? sym.container.getType().constructorScope : sym.container.instanceScope(); if(TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Property) && sym.container.declAST.nodeType == TypeScript.NodeType.FuncDecl) { this.thisFnc = sym.container.declAST; } if(instanceScope) { var prevScope = this.scope; this.scope = instanceScope; var container = sym.container; if(this.checker.units && (sym.unitIndex >= 0) && (sym.unitIndex < this.checker.units.length)) { this.checker.locationInfo = this.checker.units[sym.unitIndex]; } else { this.checker.locationInfo = TypeScript.unknownLocationInfo; } while(container) { if(container.kind() == TypeScript.SymbolKind.Type) { var typeSym = container; var type = typeSym.type; if(type.call) { this.enclosingFncIsMethod = typeSym.isMethod; } if(type.isClass()) { this.thisType = type.instanceType; break; } } container = container.container; } this.typeCheckBoundDecl(varDecl); this.scope = prevScope; } } this.thisFnc = svThisFnc; this.thisType = svThisType; this.checker.locationInfo = prevLocationInfo; this.enclosingFncIsMethod = prevMethodStatus; }; TypeFlow.prototype.resolveBoundDecl = function (varDecl) { if(varDecl.typeExpr) { if(varDecl.typeExpr.type == null || (varDecl.typeExpr.type && varDecl.typeExpr.type == this.anyType && this.scope) || varDecl.typeExpr.type.symbol == null || !this.checker.typeStatusIsFinished(varDecl.typeExpr.type.symbol.typeCheckStatus)) { this.typeCheck(varDecl.typeExpr); } varDecl.type = varDecl.typeExpr.type; if(varDecl.sym) { varDecl.sym.setType(varDecl.type); } } else { if(varDecl.init == null) { if(this.checker.styleSettings.implicitAny) { this.checker.errorReporter.styleError(varDecl, "type implicitly set to 'any'"); } varDecl.type = this.anyType; if(varDecl.sym) { if(varDecl.sym.isType()) { var tsym = varDecl.sym; if(tsym.isMethod) { this.checker.errorReporter.simpleError(varDecl, "Cannot bind method group to variable. (Did you mean to use 'declare function' instead of 'declare var'?)"); return; } else { this.checker.errorReporter.simpleError(varDecl, "Cannot bind type to variable"); return; } } varDecl.sym.setType(varDecl.type); } } } }; TypeFlow.prototype.typeCheckBoundDecl = function (varDecl) { var _this = this; var infSym = varDecl.sym; if(infSym == null) { if(varDecl.init) { varDecl.init = this.typeCheck(varDecl.init); varDecl.type = this.checker.widenType(varDecl.init.type); } else { if(this.checker.styleSettings.implicitAny) { this.checker.errorReporter.styleError(varDecl, "type implicitly set to 'any'"); } varDecl.type = this.anyType; } } else { if(infSym.typeCheckStatus == TypeScript.TypeCheckStatus.Started) { if(this.checker.styleSettings.implicitAny) { this.checker.errorReporter.styleError(varDecl, "type implicitly set to 'any'"); } varDecl.type = this.anyType; infSym.setType(this.anyType); } else { if(infSym.typeCheckStatus == TypeScript.TypeCheckStatus.NotStarted) { infSym.typeCheckStatus = TypeScript.TypeCheckStatus.Started; this.checker.addStartedPTO(infSym); var resolved = false; if(varDecl.type == null) { if(varDecl.typeExpr) { this.resolveBoundDecl(varDecl); resolved = true; varDecl.type = varDecl.typeExpr.type; infSym.typeCheckStatus = this.checker.getTypeCheckFinishedStatus(); } } if(varDecl.init) { var isLocalStatic = TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.LocalStatic); var prevScope = this.scope; var applyTargetType = !varDecl.init.isParenthesized; if(isLocalStatic) { this.scope = varDecl.sym.container.getType().memberScope; } if(TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Property) && this.thisClassNode) { TypeScript.getAstWalkerFactory().walk(varDecl.init, function (ast, parent, walker) { if(ast && ast.nodeType == TypeScript.NodeType.FuncDecl) { if(TypeScript.hasFlag((ast).fncFlags, TypeScript.FncFlags.IsFatArrowFunction)) { (ast).fncFlags |= TypeScript.FncFlags.IsPropertyBound; } walker.options.goChildren = false; } return ast; }); } this.checker.typeCheckWithContextualType(varDecl.type, this.checker.inProvisionalTypecheckMode(), applyTargetType, varDecl.init); this.scope = prevScope; if(varDecl.type) { var preserveScope = false; var preservedContainedScope = null; if(varDecl.init.type) { preservedContainedScope = varDecl.init.type.containedScope; preserveScope = true; if(varDecl.init.type == this.voidType) { this.checker.errorReporter.simpleError(varDecl, "Cannot assign type 'void' to variable '" + varDecl.id.actualText + "'"); } } varDecl.init = this.castWithCoercion(varDecl.init, varDecl.type, applyTargetType && !this.checker.inProvisionalTypecheckMode(), false); if(preserveScope && varDecl.init.type.containedScope == null) { varDecl.init.type.containedScope = preservedContainedScope; } } else { varDecl.type = this.checker.widenType(varDecl.init.type); if(varDecl.type == this.voidType) { this.checker.errorReporter.simpleError(varDecl, "Cannot assign type 'void' to variable '" + varDecl.id.actualText + "'"); varDecl.type = this.anyType; } } infSym.setType(varDecl.type); } else { if(!resolved) { this.resolveBoundDecl(varDecl); } } infSym.typeCheckStatus = this.checker.getTypeCheckFinishedStatus(); } else { if(this.checker.typeStatusIsFinished(infSym.typeCheckStatus) && (infSym.declAST != varDecl)) { if(varDecl.init) { varDecl.init = this.typeCheck(varDecl.init); varDecl.type = infSym.getType(); varDecl.init = this.cast(varDecl.init, varDecl.type); } } } } } if(varDecl.id && varDecl.sym) { varDecl.id.sym = varDecl.sym; } if(varDecl.sym && varDecl.sym.container) { this.checkTypePrivacy(varDecl.sym.getType(), varDecl.sym, function (typeName, isModuleName) { return _this.varPrivacyErrorReporter(varDecl, typeName, isModuleName); }); } return varDecl; }; TypeFlow.prototype.varPrivacyErrorReporter = function (varDecl, typeName, isModuleName) { var typestring = ""; if(isModuleName) { var quotestring = ""; if(!TypeScript.isQuoted(typeName)) { quotestring = "'"; } typestring = " is using inaccessible module " + quotestring + typeName + quotestring; } else { typestring = " has or is using private type '" + typeName + "'"; } if(TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Public)) { if(varDecl.sym.container.declAST.nodeType == TypeScript.NodeType.InterfaceDeclaration) { this.checker.errorReporter.simpleError(varDecl, "property '" + varDecl.sym.name + "' of exported interface" + typestring); } else { this.checker.errorReporter.simpleError(varDecl, "public member '" + varDecl.sym.name + "' of exported class" + typestring); } } else { this.checker.errorReporter.simpleError(varDecl, "exported variable '" + varDecl.sym.name + "'" + typestring); } }; TypeFlow.prototype.typeCheckSuper = function (ast) { if(this.thisType && (this.enclosingFncIsMethod && !this.thisFnc.isStatic()) && this.thisType.baseClass()) { ast.type = this.thisType.baseClass(); } else { if(!this.enclosingFncIsMethod && this.thisType && this.thisType.baseClass() && this.thisFnc && TypeScript.hasFlag(this.thisFnc.fncFlags, TypeScript.FncFlags.IsFatArrowFunction)) { var enclosingFnc = this.thisFnc.enclosingFnc; while(TypeScript.hasFlag(enclosingFnc.fncFlags, TypeScript.FncFlags.IsFatArrowFunction)) { enclosingFnc = enclosingFnc.enclosingFnc; } if(enclosingFnc && (enclosingFnc.isMethod() || enclosingFnc.isConstructor) && !enclosingFnc.isStatic()) { ast.type = this.thisType.baseClass(); enclosingFnc.setHasSuperReferenceInFatArrowFunction(); return ast; } } ast.type = this.anyType; this.checker.errorReporter.invalidSuperReference(ast); } return ast; }; TypeFlow.prototype.typeCheckThis = function (ast) { ast.type = this.anyType; var illegalThisRef = false; if(this.thisFnc == null) { if(this.thisType) { if(this.thisClassNode && this.thisClassNode.nodeType == TypeScript.NodeType.ClassDeclaration) { illegalThisRef = true; } else { ast.type = this.thisType; } } else { if(this.checker.currentModDecl) { this.checker.errorReporter.simpleError(ast, "'this' may not be referenced within module bodies"); } } } else { if(this.thisClassNode && (TypeScript.hasFlag(this.thisFnc.fncFlags, TypeScript.FncFlags.IsPropertyBound) || (this.inSuperCall && TypeScript.hasFlag((this.thisClassNode).varFlags, TypeScript.VarFlags.ClassSuperMustBeFirstCallInConstructor)))) { illegalThisRef = true; } if(this.thisFnc.isMethod() || this.thisFnc.isConstructor || this.thisFnc.isTargetTypedAsMethod) { if(this.thisType && !(this.thisFnc.fncFlags & TypeScript.FncFlags.Static)) { ast.type = this.thisType; } } } if(!this.enclosingFncIsMethod && this.thisFnc && TypeScript.hasFlag(this.thisFnc.fncFlags, TypeScript.FncFlags.IsFatArrowFunction)) { if(this.thisFnc.boundToProperty) { var container = this.thisFnc.boundToProperty.sym.container; if(container.declAST.nodeType == TypeScript.NodeType.FuncDecl) { (container.declAST).setHasSelfReference(); } } else { var encFnc = this.thisFnc.enclosingFnc; var firstEncFnc = encFnc; while(encFnc) { if(this.thisClassNode && TypeScript.hasFlag(encFnc.fncFlags, TypeScript.FncFlags.IsPropertyBound)) { illegalThisRef = true; } if(!TypeScript.hasFlag(encFnc.fncFlags, TypeScript.FncFlags.IsFatArrowFunction) || encFnc.hasSelfReference()) { encFnc.setHasSelfReference(); break; } encFnc = encFnc.enclosingFnc; } if(!encFnc && firstEncFnc) { encFnc = firstEncFnc; encFnc.setHasSelfReference(); } else { if(!encFnc) { if(this.thisClassNode) { (this.thisClassNode).varFlags |= TypeScript.VarFlags.MustCaptureThis; } else { if(this.checker.currentModDecl) { this.checker.currentModDecl.modFlags |= TypeScript.ModuleFlags.MustCaptureThis; } else { this.checker.mustCaptureGlobalThis = true; } } } } if(encFnc && (encFnc.isMethod() || encFnc.isConstructor) && this.thisType && !TypeScript.hasFlag(encFnc.fncFlags, TypeScript.FncFlags.Static)) { ast.type = this.thisType; } } } if(illegalThisRef) { this.checker.errorReporter.simpleError(ast, "Keyword 'this' cannot be referenced in initializers in a class body, or in super constructor calls"); } return ast; }; TypeFlow.prototype.setTypeFromSymbol = function (ast, symbol) { if(symbol.isVariable()) { if(symbol.isInferenceSymbol()) { var infSym = symbol; if(infSym.declAST && !this.checker.typeStatusIsFinished(infSym.typeCheckStatus)) { this.inScopeTypeCheckDecl(infSym.declAST); } if(!this.checker.styleSettings.innerScopeDeclEscape) { if(infSym.declAST && (infSym.declAST.nodeType == TypeScript.NodeType.VarDecl)) { if(this.nestingLevel < (infSym.declAST).nestingLevel) { this.checker.errorReporter.styleError(ast, "Illegal reference to a variable defined in more nested scope"); } } } } ast.type = symbol.getType(); if(!symbol.writeable()) { ast.flags = ast.flags & (~(TypeScript.ASTFlags.Writeable)); } } else { if(symbol.isType()) { ast.type = symbol.getType(); ast.flags = ast.flags & (~(TypeScript.ASTFlags.Writeable)); } else { ast.type = this.anyType; this.checker.errorReporter.symbolDoesNotReferToAValue(ast, symbol.name); } } }; TypeFlow.prototype.typeCheckName = function (ast) { var _this = this; var identifier = ast; if(this.checker.inWith) { identifier.type = this.anyType; } else { var typespace = this.inTypeRefTypeCheck; var idText = identifier.text; var originalIdText = idText; var isDynamicModuleName = TypeScript.isQuoted(identifier.text); var symbol = this.scope.find(idText, false, typespace); if(symbol == null && isDynamicModuleName) { symbol = this.checker.findSymbolForDynamicModule(idText, this.currentScript.locationInfo.filename, function (id) { return _this.scope.find(id, false, typespace); }); } if(!symbol) { if(!identifier.isMissing()) { this.checker.errorReporter.unresolvedSymbol(identifier, identifier.text); } identifier.type = this.anyType; } else { if(TypeScript.optimizeModuleCodeGen && symbol && symbol.isType()) { var symType = symbol.getType(); if(symType && (symbol).aliasLink && (symbol).onlyReferencedAsTypeRef) { var modDecl = symType.symbol.declAST; if(modDecl && TypeScript.hasFlag(modDecl.modFlags, TypeScript.ModuleFlags.IsDynamic)) { (symbol).onlyReferencedAsTypeRef = this.inTypeRefTypeCheck; } } } if(symbol.declAST && symbol.declAST.nodeType == TypeScript.NodeType.FuncDecl && !(symbol.declAST).returnTypeAnnotation && (symbol.declAST).signature.typeCheckStatus == TypeScript.TypeCheckStatus.Started) { (symbol.declAST).type.symbol.flags |= TypeScript.SymbolFlags.RecursivelyReferenced; (symbol.declAST).signature.returnType.type = this.anyType; } this.setTypeFromSymbol(ast, symbol); identifier.sym = symbol; if(this.thisFnc) { if(this.thisFnc.type && symbol.container != this.thisFnc.type.symbol) { this.thisFnc.freeVariables[this.thisFnc.freeVariables.length] = symbol; } } } } return ast; }; TypeFlow.prototype.typeCheckScript = function (script) { this.checker.locationInfo = script.locationInfo; this.scope = this.checker.globalScope; if(!script.topLevelMod) { this.addLocalsFromScope(this.scope, this.checker.gloMod, script.vars, this.checker.globals, true); } this.currentScript = script; script.bod = this.typeCheck(script.bod); this.currentScript = null; return script; }; TypeFlow.prototype.typeCheckBitNot = function (ast) { var unex = ast; unex.operand = this.typeCheck(unex.operand); unex.type = this.doubleType; return unex; }; TypeFlow.prototype.typeCheckUnaryNumberOperator = function (ast) { var unex = ast; unex.operand = this.typeCheck(unex.operand); unex.type = this.doubleType; return ast; }; TypeFlow.prototype.typeCheckLogNot = function (ast) { var unex = ast; unex.operand = this.typeCheck(unex.operand); unex.type = this.booleanType; return unex; }; TypeFlow.prototype.astIsWriteable = function (ast) { return TypeScript.hasFlag(ast.flags, TypeScript.ASTFlags.Writeable); }; TypeFlow.prototype.typeCheckIncOrDec = function (ast) { var unex = ast; var lval = unex.operand; if(!this.astIsWriteable(unex)) { this.checker.errorReporter.valueCannotBeModified(unex); unex.type = this.doubleType; } else { unex = this.typeCheckUnaryNumberOperator(ast); if(unex.operand.type != this.checker.numberType && unex.operand.type != this.checker.anyType && !(unex.operand.type.typeFlags & TypeScript.TypeFlags.IsEnum)) { this.checker.errorReporter.simpleError(ast, "'++' and '--' may only be applied to operands of type 'number' or 'any'"); } } return unex; }; TypeFlow.prototype.typeCheckBitwiseOperator = function (ast, assignment) { var binex = ast; var resultType = null; binex.operand1 = this.typeCheck(binex.operand1); binex.operand2 = this.typeCheck(binex.operand2); var leftType = binex.operand1.type; var rightType = binex.operand2.type; if(assignment && (!this.astIsWriteable(binex))) { this.checker.errorReporter.valueCannotBeModified(binex); } if(this.checker.styleSettings.bitwise) { this.checker.errorReporter.styleError(ast, "use of " + TypeScript.nodeTypeTable[binex.nodeType]); } if(this.checker.sourceIsSubtypeOfTarget(leftType, this.doubleType) && (this.checker.sourceIsSubtypeOfTarget(rightType, this.doubleType))) { resultType = this.doubleType; } else { if((leftType == this.booleanType) && (rightType == this.booleanType)) { resultType = this.booleanType; } else { if(leftType == this.anyType) { if((rightType == this.anyType) || (rightType == this.doubleType) || (rightType == this.booleanType)) { resultType = this.anyType; } } else { if(rightType == this.anyType) { if((leftType == this.anyType) || (leftType == this.doubleType) || (leftType == this.booleanType)) { resultType = this.anyType; } } } } } if(resultType == null) { resultType = this.anyType; this.checker.errorReporter.incompatibleTypes(binex, leftType, rightType, binex.printLabel(), this.scope); } binex.type = resultType; return binex; }; TypeFlow.prototype.typeCheckArithmeticOperator = function (ast, assignment) { var binex = ast; binex.operand1 = this.typeCheck(binex.operand1); binex.operand2 = this.typeCheck(binex.operand2); var leftType = binex.operand1.type; var rightType = binex.operand2.type; if(assignment && (!this.astIsWriteable(binex.operand1))) { this.checker.errorReporter.valueCannotBeModified(binex); } if(this.checker.styleSettings.bitwise && ((binex.nodeType == TypeScript.NodeType.And) || (binex.nodeType == TypeScript.NodeType.Or) || (binex.nodeType == TypeScript.NodeType.AsgAnd) || (binex.nodeType == TypeScript.NodeType.AsgOr))) { this.checker.errorReporter.styleError(ast, "use of " + TypeScript.nodeTypeTable[binex.nodeType]); } if(leftType == null || rightType == null) { this.checker.errorReporter.simpleError(binex, "Could not typecheck arithmetic operation. Possible recursive typecheck error?"); binex.type = this.anyType; return binex; } var nodeType = binex.nodeType; if(this.checker.isNullOrUndefinedType(leftType)) { leftType = rightType; } if(this.checker.isNullOrUndefinedType(rightType)) { rightType = leftType; } leftType = this.checker.widenType(leftType); rightType = this.checker.widenType(rightType); if(nodeType == TypeScript.NodeType.Add || nodeType == TypeScript.NodeType.AsgAdd) { if(leftType == this.checker.stringType || rightType == this.checker.stringType) { binex.type = this.checker.stringType; } else { if(leftType == this.checker.numberType && rightType == this.checker.numberType) { binex.type = this.checker.numberType; } else { if(this.checker.sourceIsSubtypeOfTarget(leftType, this.checker.numberType) && this.checker.sourceIsSubtypeOfTarget(rightType, this.checker.numberType)) { binex.type = this.checker.numberType; } else { if(leftType == this.checker.anyType || rightType == this.checker.anyType) { binex.type = this.checker.anyType; } else { binex.type = this.anyType; this.checker.errorReporter.incompatibleTypes(binex, leftType, rightType, binex.printLabel(), this.scope); } } } } } else { if(leftType == this.checker.numberType && rightType == this.checker.numberType) { binex.type = this.checker.numberType; } else { if(this.checker.sourceIsSubtypeOfTarget(leftType, this.checker.numberType) && this.checker.sourceIsSubtypeOfTarget(rightType, this.checker.numberType)) { binex.type = this.checker.numberType; } else { if(leftType == this.checker.anyType || rightType == this.checker.anyType) { binex.type = this.checker.numberType; } else { binex.type = this.anyType; this.checker.errorReporter.incompatibleTypes(binex, leftType, rightType, binex.printLabel(), this.scope); } } } } return binex; }; TypeFlow.prototype.typeCheckDotOperator = function (ast) { var binex = ast; var leftIsFnc = false; binex.operand1 = this.typeCheck(binex.operand1); var leftType = binex.operand1.type; var leftScope = null; if(leftType) { if(leftType == this.anyType) { binex.type = this.anyType; return binex; } else { if(leftType == this.stringType) { if(this.stringInterfaceType) { leftScope = this.stringInterfaceType.memberScope; } else { binex.type = this.anyType; return binex; } } else { if(leftType == this.doubleType) { if(this.numberInterfaceType) { leftScope = this.numberInterfaceType.memberScope; } else { binex.type = this.anyType; return binex; } } else { if(leftType == this.booleanType) { if(this.booleanInterfaceType) { leftScope = this.booleanInterfaceType.memberScope; } else { binex.type = this.anyType; return binex; } } else { if((leftType.call || leftType.construct) && leftType.members == null) { if(this.functionInterfaceType) { leftScope = this.functionInterfaceType.memberScope; } else { binex.type = this.anyType; return binex; } } else { if(leftType.elementType) { if(this.arrayInterfaceType) { var arrInstType = leftType.elementType.getArrayBase(this.arrayInterfaceType, this.checker); leftScope = arrInstType.memberScope; } else { binex.type = this.anyType; return binex; } } else { leftScope = leftType.memberScope; } } } } } } } if(leftScope == null) { this.checker.errorReporter.expectedClassOrInterface(binex); binex.type = this.anyType; } else { var propertyName = binex.operand2; var lhsIsEnclosingType = (this.thisClassNode && binex.operand1.type == this.thisClassNode.type.instanceType) || this.inTypeRefTypeCheck; var symbol = leftScope.find(propertyName.text, !lhsIsEnclosingType, this.inTypeRefTypeCheck); if(!symbol) { if(this.objectInterfaceType && leftType) { if(leftType.isReferenceType()) { symbol = this.objectInterfaceType.memberScope.find(propertyName.text, false, this.inTypeRefTypeCheck); } if(!symbol) { if(this.functionInterfaceType && (leftType.call || leftType.construct)) { symbol = this.functionInterfaceType.memberScope.find(propertyName.text, false, this.inTypeRefTypeCheck); } } } } if(!symbol || (!symbol.visible(leftScope, this.checker))) { binex.type = this.anyType; if(symbol == null) { this.checker.errorReporter.simpleError(propertyName, "The property '" + propertyName.actualText + "' does not exist on value of type '" + leftType.getScopedTypeName(this.scope) + "'"); } else { if(!this.inTypeRefTypeCheck) { this.checker.errorReporter.simpleError(binex, "The property '" + propertyName.actualText + " on type '" + leftType.getScopedTypeName(this.scope) + "' is not visible"); } } } else { if(symbol.isVariable()) { if(symbol.isInferenceSymbol()) { var infSym = symbol; if(infSym.declAST && !this.checker.typeStatusIsFinished(infSym.typeCheckStatus)) { this.inScopeTypeCheckDecl(infSym.declAST); } } } propertyName.sym = symbol; binex.type = symbol.getType(); } } if(binex.type == null) { binex.type = this.anyType; } return binex; }; TypeFlow.prototype.typeCheckBooleanOperator = function (ast) { var binex = ast; binex.operand1 = this.typeCheck(binex.operand1); binex.operand2 = this.typeCheck(binex.operand2); var leftType = binex.operand1.type; var rightType = binex.operand2.type; if((!(this.checker.sourceIsAssignableToTarget(leftType, rightType))) && (!(this.checker.sourceIsAssignableToTarget(rightType, leftType)))) { this.checker.errorReporter.incompatibleTypes(binex, leftType, rightType, binex.printLabel(), this.scope); } binex.type = this.booleanType; return binex; }; TypeFlow.prototype.typeCheckAsgOperator = function (ast) { var binex = ast; var applyTargetType = !binex.operand2.isParenthesized; binex.operand1 = this.typeCheck(binex.operand1); this.checker.typeCheckWithContextualType(binex.operand1.type, this.checker.inProvisionalTypecheckMode(), applyTargetType, binex.operand2); var leftType = binex.operand1.type; var rightType = binex.operand2.type; if(!(this.astIsWriteable(binex.operand1))) { this.checker.errorReporter.valueCannotBeModified(binex); } if(binex.operand1.nodeType == TypeScript.NodeType.Call) { var callEx = binex.operand1; } var preserveScope = false; var preservedContainedScope = null; if(binex.operand2.type) { preservedContainedScope = binex.operand2.type.containedScope; preserveScope = true; } binex.operand2 = this.castWithCoercion(binex.operand2, leftType, applyTargetType && !this.checker.inProvisionalTypecheckMode(), false); if(preserveScope && binex.operand2.type.containedScope == null) { binex.operand2.type.containedScope = preservedContainedScope; } binex.type = rightType; return binex; }; TypeFlow.prototype.typeCheckIndex = function (ast) { var binex = ast; binex.operand1 = this.typeCheck(binex.operand1); binex.operand2 = this.typeCheck(binex.operand2); if(!this.checker.styleSettings.literalSubscript) { if(binex.operand2.nodeType == TypeScript.NodeType.QString) { this.checker.errorReporter.styleError(ast, "use literal subscript ('.') notation instead)"); } } var objExprType = binex.operand1.type; var indexExprType = binex.operand2.type; if(objExprType.elementType) { if(indexExprType == this.checker.anyType || indexExprType == this.checker.numberType || TypeScript.hasFlag(indexExprType.typeFlags, TypeScript.TypeFlags.IsEnum)) { binex.type = objExprType.elementType; } else { if(indexExprType == this.checker.stringType) { binex.type = this.checker.anyType; } else { this.checker.errorReporter.simpleError(binex, "Illegal property access"); binex.type = this.checker.anyType; } } } else { if(objExprType.index) { if(indexExprType == this.checker.anyType || !((objExprType.index.flags & TypeScript.SignatureFlags.IsStringIndexer) || (objExprType.index.flags & TypeScript.SignatureFlags.IsNumberIndexer)) || ((objExprType.index.flags & TypeScript.SignatureFlags.IsStringIndexer) && indexExprType == this.checker.stringType) || ((objExprType.index.flags & TypeScript.SignatureFlags.IsNumberIndexer) && (indexExprType == this.checker.numberType || TypeScript.hasFlag(indexExprType.typeFlags, TypeScript.TypeFlags.IsEnum)))) { var sig = this.resolveOverload(ast, objExprType.index); if(sig) { binex.type = sig.returnType.type; } else { binex.type = this.checker.anyType; } } else { if(indexExprType == this.checker.stringType) { binex.type = this.checker.anyType; } else { this.checker.errorReporter.simpleError(binex, "Illegal property access"); binex.type = this.checker.anyType; } } } else { if((objExprType == this.checker.anyType || objExprType == this.checker.stringType || objExprType == this.checker.numberType || objExprType == this.checker.booleanType || objExprType.isReferenceType()) && (indexExprType == this.checker.anyType || indexExprType == this.checker.stringType || (indexExprType == this.checker.numberType || TypeScript.hasFlag(indexExprType.typeFlags, TypeScript.TypeFlags.IsEnum)))) { binex.type = this.checker.anyType; } else { this.checker.errorReporter.simpleError(binex, "Illegal property access"); binex.type = this.checker.anyType; } } } return binex; }; TypeFlow.prototype.typeCheckInOperator = function (binex) { binex.operand1 = this.cast(this.typeCheck(binex.operand1), this.stringType); binex.operand2 = this.typeCheck(binex.operand2); if(!((binex.operand1.type == this.checker.anyType || binex.operand1.type == this.checker.stringType) && (binex.operand2.type == this.anyType || this.checker.sourceIsSubtypeOfTarget(binex.operand2.type, this.objectInterfaceType)))) { this.checker.errorReporter.simpleError(binex, "The in operator requires the left operand to be of type Any or the String primitive type, and the right operand to be of type Any or an object type"); } binex.type = this.booleanType; return binex; }; TypeFlow.prototype.typeCheckShift = function (binex, assignment) { binex.operand1 = this.cast(this.typeCheck(binex.operand1), this.doubleType); binex.operand2 = this.cast(this.typeCheck(binex.operand2), this.doubleType); if(assignment && (!(this.astIsWriteable(binex.operand1)))) { this.checker.errorReporter.valueCannotBeModified(binex); } binex.type = this.doubleType; return binex; }; TypeFlow.prototype.typeCheckQMark = function (trinex) { trinex.operand1 = this.typeCheck(trinex.operand1); trinex.operand2 = this.typeCheck(trinex.operand2); trinex.operand3 = this.typeCheck(trinex.operand3); var leftType = trinex.operand2.type; var rightType = trinex.operand3.type; if(leftType == rightType) { trinex.type = leftType; } else { if(this.checker.sourceIsSubtypeOfTarget(leftType, rightType)) { trinex.type = rightType; } else { if(this.checker.sourceIsSubtypeOfTarget(rightType, leftType)) { trinex.type = leftType; } else { trinex.type = this.anyType; this.checker.errorReporter.incompatibleTypes(trinex, leftType, rightType, trinex.printLabel(), this.scope); } } } return trinex; }; TypeFlow.prototype.addFormals = function (container, signature, table) { var len = signature.parameters.length; for(var i = 0; i < len; i++) { var symbol = signature.parameters[i]; symbol.container = container; table.add(symbol.name, symbol); } }; TypeFlow.prototype.addLocalsFromScope = function (scope, container, vars, table, isModContainer) { var len = vars.members.length; var hasArgsDef = false; for(var i = 0; i < len; i++) { var local = vars.members[i]; if(((local.sym == null) || (local.sym.kind() != TypeScript.SymbolKind.Field))) { var result = null; if((result = table.lookup(local.id.text)) == null) { var localVar = new TypeScript.ValueLocation(); localVar.typeLink = new TypeScript.TypeLink(); var varSym = null; if(TypeScript.hasFlag(local.varFlags, TypeScript.VarFlags.Static)) { local.varFlags |= TypeScript.VarFlags.LocalStatic; varSym = new TypeScript.FieldSymbol(local.id.text, local.minChar, this.checker.locationInfo.unitIndex, true, localVar); } else { varSym = new TypeScript.VariableSymbol(local.id.text, local.minChar, this.checker.locationInfo.unitIndex, localVar); } varSym.transferVarFlags(local.varFlags); localVar.symbol = varSym; varSym.declAST = local; localVar.typeLink.ast = local.typeExpr; this.checker.resolveTypeLink(scope, localVar.typeLink, false); if((local.type == null) && (local.init == null)) { local.type = this.anyType; } localVar.typeLink.type = local.type; localVar.symbol.container = container; local.sym = localVar.symbol; table.add(local.id.text, varSym); if(local.id.text == "arguments") { hasArgsDef = true; } } else { local.type = result.getType(); local.sym = result; } } } if(!isModContainer) { if(!hasArgsDef) { var argLoc = new TypeScript.ValueLocation(); argLoc.typeLink = new TypeScript.TypeLink(); var theArgSym = new TypeScript.VariableSymbol("arguments", vars.minChar, this.checker.locationInfo.unitIndex, argLoc); if(!this.iargumentsInterfaceType) { var argumentsSym = scope.find("IArguments", false, true); if(argumentsSym) { argumentsSym.flags |= TypeScript.SymbolFlags.CompilerGenerated; this.iargumentsInterfaceType = argumentsSym.getType(); } else { this.iargumentsInterfaceType = this.anyType; } } argLoc.typeLink.type = this.iargumentsInterfaceType; table.add("arguments", theArgSym); } } }; TypeFlow.prototype.addConstructorLocalArgs = function (container, args, table, isClass) { if(args) { var len = args.members.length; for(var i = 0; i < len; i++) { var local = args.members[i]; if((local.sym == null) || (isClass || (local.sym.kind() != TypeScript.SymbolKind.Field))) { var result = null; if((result = table.lookup(local.id.text)) == null) { this.resolveBoundDecl(local); var localVar = new TypeScript.ValueLocation(); localVar.typeLink = new TypeScript.TypeLink(); var varSym = new TypeScript.ParameterSymbol(local.id.text, local.minChar, this.checker.locationInfo.unitIndex, localVar); varSym.declAST = local; localVar.symbol = varSym; localVar.typeLink.type = local.type; localVar.symbol.container = container; local.sym = localVar.symbol; table.add(local.id.text, varSym); } else { local.type = result.getType(); local.sym = result; } } } } }; TypeFlow.prototype.checkInitSelf = function (funcDecl) { if(!funcDecl.isMethod()) { var freeVars = funcDecl.freeVariables; for(var k = 0, len = freeVars.length; k < len; k++) { var sym = freeVars[k]; if(sym.isInstanceProperty()) { return true; } } } var fns = funcDecl.scopes; var fnsLen = fns.members.length; for(var j = 0; j < fnsLen; j++) { var fn = fns.members[j]; if(this.checkInitSelf(fn)) { return true; } } return false; }; TypeFlow.prototype.checkPromoteFreeVars = function (funcDecl, constructorSym) { var freeVars = funcDecl.freeVariables; for(var k = 0, len = freeVars.length; k < len; k++) { var sym = freeVars[k]; if((!sym.isInstanceProperty()) && (sym.container == constructorSym)) { TypeScript.instanceFilter.reset(); if(this.scope.search(TypeScript.instanceFilter, sym.name, false, false)) { this.checker.errorReporter.simpleError(funcDecl, "Constructor-local variable shadows class property '" + sym.name + "'. To access the class property, use 'self." + sym.name + "'"); } this.checker.errorReporter.simpleError(funcDecl, "Constructor-local variables may not be accessed from instance method bodies. Consider changing local variable '" + sym.name + "' to a class property"); } } }; TypeFlow.prototype.allReturnsAreVoid = function (funcDecl) { var allReturnsAreVoid = true; if(funcDecl.signature.returnType.type == null) { var preFindReturnExpressionTypes = function (ast, parent, walker) { var go = true; switch(ast.nodeType) { case TypeScript.NodeType.FuncDecl: { go = false; break; } case TypeScript.NodeType.Return: { var returnStmt = ast; if(returnStmt.returnExpression) { allReturnsAreVoid = false; go = false; } } default: { break; } } walker.options.goChildren = go; walker.options.goNextSibling = go; return ast; }; TypeScript.getAstWalkerFactory().walk(funcDecl.bod, preFindReturnExpressionTypes); } return allReturnsAreVoid; }; TypeFlow.prototype.classConstructorHasSuperCall = function (funcDecl) { var foundSuper = false; var preFindSuperCall = function (ast, parent, walker) { var go = true; switch(ast.nodeType) { case TypeScript.NodeType.FuncDecl: { go = false; break; } case TypeScript.NodeType.Call: { var call = ast; if(call.target.nodeType == TypeScript.NodeType.Super) { go = false; foundSuper = true; break; } break; } default: { break; } } walker.options.goChildren = go; return ast; }; TypeScript.getAstWalkerFactory().walk(funcDecl.bod, preFindSuperCall); return foundSuper; }; TypeFlow.prototype.baseListPrivacyErrorReporter = function (bases, i, declSymbol, extendsList, typeName, isModuleName) { var baseSymbol = bases.members[i].type.symbol; var declTypeString = (declSymbol.declAST.nodeType == TypeScript.NodeType.InterfaceDeclaration) ? "interface" : "class"; var baseListTypeString = extendsList ? "extends" : "implements"; var baseTypeString = (baseSymbol.declAST.nodeType == TypeScript.NodeType.InterfaceDeclaration) ? "interface" : "class"; var typestring = ""; if(isModuleName) { var quotestring = ""; if(!TypeScript.isQuoted(typeName)) { quotestring = "'"; } typestring = " is using inaccessible module "; baseTypeString = " " + baseTypeString + " from private module " + quotestring + typeName + quotestring; } else { baseTypeString = " private " + baseTypeString + " '" + typeName + "'"; } this.checker.errorReporter.simpleError(bases.members[i], "exported " + declTypeString + " '" + declSymbol.name + "' " + baseListTypeString + baseTypeString); }; TypeFlow.prototype.typeCheckBaseListPrivacy = function (bases, declSymbol, extendsList) { var _this = this; if(bases) { var basesLen = bases.members.length; for(var i = 0; i < basesLen; i++) { if(!bases.members[i].type || bases.members[i].type == this.checker.anyType) { continue; } this.checkSymbolPrivacy(bases.members[i].type.symbol, declSymbol, function (typeName, isModuleName) { return _this.baseListPrivacyErrorReporter(bases, i, declSymbol, extendsList, typeName, isModuleName); }); } } }; TypeFlow.prototype.checkSymbolPrivacy = function (typeSymbol, declSymbol, errorCallback) { var externalModuleSymbol = null; var declSymbolPath = null; if(typeSymbol.isExternallyVisible(this.checker)) { var typeSymbolPath = typeSymbol.pathToRoot(); declSymbolPath = declSymbol.pathToRoot(); var typeSymbolLength = typeSymbolPath.length; var declSymbolPathLength = declSymbolPath.length; if(typeSymbolLength > 0) { if(typeSymbolPath[typeSymbolLength - 1].getType().isModuleType() && (typeSymbolPath[typeSymbolLength - 1]).isDynamic && typeSymbolPath[typeSymbolLength - 1] != declSymbolPath[declSymbolPathLength - 1]) { externalModuleSymbol = typeSymbolPath[typeSymbolLength - 1]; } else { if(typeSymbolLength > 1) { if(typeSymbolPath[typeSymbolLength - 2].getType().isModuleType() && (typeSymbolPath[typeSymbolLength - 2]).isDynamic && (declSymbolPathLength == 1 || typeSymbolPath[typeSymbolLength - 2] != declSymbolPath[declSymbolPathLength - 2])) { externalModuleSymbol = typeSymbolPath[typeSymbolLength - 2]; } } } } if(externalModuleSymbol == null) { return; } } var interfaceDecl = declSymbol.getInterfaceDeclFromSymbol(this.checker); if(interfaceDecl && !TypeScript.hasFlag(interfaceDecl.varFlags, TypeScript.VarFlags.Exported)) { return; } var checkVisibilitySymbol = declSymbol; var varDecl = declSymbol.getVarDeclFromSymbol(); if(varDecl) { if(TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Private)) { return; } else { if(TypeScript.hasFlag(varDecl.varFlags, TypeScript.VarFlags.Public)) { checkVisibilitySymbol = declSymbol.container; } } } if(checkVisibilitySymbol.isExternallyVisible(this.checker)) { var privateSymbolName = typeSymbol.name; if(externalModuleSymbol != null) { var prettyName = externalModuleSymbol.getPrettyNameOfDynamicModule(declSymbolPath); if(prettyName != null) { this.currentScript.AddExternallyVisibleImportedSymbol(prettyName.symbol, this.checker); return; } else { privateSymbolName = externalModuleSymbol.prettyName; } } errorCallback(privateSymbolName, typeSymbol.name != privateSymbolName); } }; TypeFlow.prototype.checkTypePrivacy = function (type, declSymbol, errorCallback) { var _this = this; if(!(type && type.primitiveTypeClass == TypeScript.Primitive.None)) { return; } if(type.isArray()) { return this.checkTypePrivacy(type.elementType, declSymbol, errorCallback); } if(type.symbol && type.symbol.name && type.symbol.name != "_anonymous" && (((type.call == null) && (type.construct == null) && (type.index == null)) || (type.members && (!type.isClass())))) { return this.checkSymbolPrivacy(type.symbol, declSymbol, errorCallback); } if(type.members) { type.members.allMembers.map(function (key, s, unused) { var sym = s; if(!TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.BuiltIn)) { _this.checkTypePrivacy(sym.getType(), declSymbol, errorCallback); } }, null); } this.checkSignatureGroupPrivacy(type.call, declSymbol, errorCallback); this.checkSignatureGroupPrivacy(type.construct, declSymbol, errorCallback); this.checkSignatureGroupPrivacy(type.index, declSymbol, errorCallback); }; TypeFlow.prototype.checkSignatureGroupPrivacy = function (sgroup, declSymbol, errorCallback) { if(sgroup) { var len = sgroup.signatures.length; for(var i = 0; i < sgroup.signatures.length; i++) { var signature = sgroup.signatures[i]; if(len > 1 && signature == sgroup.definitionSignature) { continue; } if(signature.returnType) { this.checkTypePrivacy(signature.returnType.type, declSymbol, errorCallback); } var paramLen = signature.parameters.length; for(var j = 0; j < paramLen; j++) { var param = signature.parameters[j]; this.checkTypePrivacy(param.getType(), declSymbol, errorCallback); } } } }; TypeFlow.prototype.functionArgumentPrivacyErrorReporter = function (funcDecl, p, paramSymbol, typeName, isModuleName) { var isGetter = funcDecl.isAccessor() && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.GetAccessor); var isSetter = funcDecl.isAccessor() && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.SetAccessor); var isPublicFunc = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Public); var isContainerInterface = funcDecl.type.symbol.getInterfaceDeclFromSymbol(this.checker) != null; var typestring = ""; if(isModuleName) { var quotestring = ""; if(!TypeScript.isQuoted(typeName)) { quotestring = "'"; } typestring = " is using inaccessible module " + quotestring + typeName + quotestring; } else { typestring = " has or is using private type '" + typeName + "'"; } if(!isContainerInterface) { if(funcDecl.isConstructor) { this.checker.errorReporter.simpleError(funcDecl.arguments.members[p], "exported class's constructor parameter '" + paramSymbol.name + "'" + typestring); } else { if(isSetter) { this.checker.errorReporter.simpleError(funcDecl.arguments.members[p], (isPublicFunc ? "public" : "exported") + " setter parameter '" + paramSymbol.name + "'" + typestring); } else { if(!isGetter) { this.checker.errorReporter.simpleError(funcDecl.arguments.members[p], (isPublicFunc ? "public" : "exported") + " function parameter '" + paramSymbol.name + "'" + typestring); } } } } else { if(funcDecl.isConstructMember()) { this.checker.errorReporter.simpleError(funcDecl.arguments.members[p], "exported interface's constructor parameter '" + paramSymbol.name + "'" + typestring); } else { if(funcDecl.isCallMember()) { this.checker.errorReporter.simpleError(funcDecl.arguments.members[p], "exported interface's call parameter '" + paramSymbol.name + "'" + typestring); } else { if(!funcDecl.isIndexerMember()) { this.checker.errorReporter.simpleError(funcDecl.arguments.members[p], "exported interface's function parameter '" + paramSymbol.name + "'" + typestring); } } } } }; TypeFlow.prototype.returnTypePrivacyError = function (astError, funcDecl, typeName, isModuleName) { var isGetter = funcDecl.isAccessor() && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.GetAccessor); var isSetter = funcDecl.isAccessor() && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.SetAccessor); var isPublicFunc = TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Public); var isContainerInterface = funcDecl.type.symbol.getInterfaceDeclFromSymbol(this.checker) != null; var typestring = ""; if(isModuleName) { var quotestring = ""; if(!TypeScript.isQuoted(typeName)) { quotestring = "'"; } typestring = " is using inaccessible module " + quotestring + typeName + quotestring; } else { typestring = " has or is using private type '" + typeName + "'"; } if(!isContainerInterface) { if(isGetter) { this.checker.errorReporter.simpleError(astError, (isPublicFunc ? "public" : "exported") + " getter return type" + typestring); } else { if(!isSetter) { this.checker.errorReporter.simpleError(astError, (isPublicFunc ? "public" : "exported") + " function return type" + typestring); } } } else { if(funcDecl.isConstructMember()) { this.checker.errorReporter.simpleError(astError, "exported interface's constructor return type" + typestring); } else { if(funcDecl.isCallMember()) { this.checker.errorReporter.simpleError(astError, "exported interface's call return type" + typestring); } else { if(funcDecl.isIndexerMember()) { this.checker.errorReporter.simpleError(astError, "exported interface's indexer return type" + typestring); } else { this.checker.errorReporter.simpleError(astError, "exported interface's function return type" + typestring); } } } } }; TypeFlow.prototype.functionReturnTypePrivacyErrorReporter = function (funcDecl, signature, typeName, isModuleName) { var reportOnFuncDecl = false; if(funcDecl.returnTypeAnnotation != null && funcDecl.returnTypeAnnotation.type == signature.returnType.type) { this.returnTypePrivacyError(funcDecl.returnTypeAnnotation, funcDecl, typeName, isModuleName); } for(var i = 0; i < funcDecl.returnStatementsWithExpressions.length; i++) { if(funcDecl.returnStatementsWithExpressions[i].type == signature.returnType.type) { this.returnTypePrivacyError(funcDecl.returnStatementsWithExpressions[i], funcDecl, typeName, isModuleName); } else { reportOnFuncDecl = true; } } if(reportOnFuncDecl) { this.returnTypePrivacyError(funcDecl, funcDecl, typeName, isModuleName); } }; TypeFlow.prototype.typeCheckFunction = function (funcDecl) { var _this = this; this.nestingLevel = 0; var fnType = funcDecl.type; var fgSym = fnType.symbol; var signature = funcDecl.signature; if(this.checker.typeStatusIsFinished(signature.typeCheckStatus)) { return funcDecl; } else { if(signature.typeCheckStatus == TypeScript.TypeCheckStatus.Started) { if(!funcDecl.returnTypeAnnotation && funcDecl.bod && !funcDecl.isSignature() && !(funcDecl.isConstructor) && this.allReturnsAreVoid(funcDecl)) { signature.returnType.type = this.voidType; return funcDecl; } else { if(funcDecl.returnTypeAnnotation == null) { if(this.checker.styleSettings.implicitAny) { this.checker.errorReporter.styleError(funcDecl, "type implicitly set to 'any'"); } signature.returnType.type = this.anyType; fgSym.flags |= TypeScript.SymbolFlags.RecursivelyReferenced; } return funcDecl; } } } signature.typeCheckStatus = TypeScript.TypeCheckStatus.Started; this.checker.addStartedPTO(signature); var prevScope = this.scope; var prevFnc = this.thisFnc; var prevMethodStatus = this.enclosingFncIsMethod; var prevClassNode = this.thisClassNode; this.enclosingFncIsMethod = funcDecl.isMethod() || funcDecl.isConstructor; this.thisFnc = funcDecl; var container = funcDecl.type.symbol; var prevThisType = this.thisType; var prevLocationInfo = this.checker.locationInfo; var funcTable = null; var acceptedContextualType = false; var targetParams = null; var targetReturnType = null; var isGetter = funcDecl.isAccessor() && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.GetAccessor); var isSetter = funcDecl.isAccessor() && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.SetAccessor); var accessorType = (isGetter || isSetter) && funcDecl.accessorSymbol ? funcDecl.accessorSymbol.getType() : null; var prevModDecl = this.checker.currentModDecl; if(funcDecl.isConstructor && !funcDecl.isOverload) { if(fnType.instanceType == null) { this.checker.errorReporter.simpleError(funcDecl, "Malformed function body (is this a class named the same as an existing interface?)"); return funcDecl; } this.scope = fnType.instanceType.constructorScope; var ssb = this.scope; funcTable = ssb.valueMembers.allMembers; } else { if((funcDecl.isSpecialFn() && !(funcDecl.fncFlags & TypeScript.FncFlags.Signature)) || funcDecl.isOverload) { funcTable = funcDecl.symbols; if(!TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Static) && fnType.containedScope) { this.scope = fnType.containedScope; } } else { if(funcDecl.bod) { this.scope = fnType.containedScope; } var ssb = this.scope; if(ssb && ssb.valueMembers) { funcTable = ssb.valueMembers.allMembers; } } } if(funcDecl.isConstructor && funcDecl.bod && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod)) { var hasBaseType = TypeScript.hasFlag(funcDecl.classDecl.type.instanceType.typeFlags, TypeScript.TypeFlags.HasBaseType); var noSuperCallAllowed = !hasBaseType || TypeScript.hasFlag(funcDecl.classDecl.type.instanceType.typeFlags, TypeScript.TypeFlags.HasBaseTypeOfObject); var superCallMustBeFirst = TypeScript.hasFlag((funcDecl.classDecl).varFlags, TypeScript.VarFlags.ClassSuperMustBeFirstCallInConstructor); if(noSuperCallAllowed && this.classConstructorHasSuperCall(funcDecl)) { this.checker.errorReporter.simpleError(funcDecl, "Calls to 'super' constructor are not allowed in classes that either inherit directly from 'Object' or have no base class"); } else { if(hasBaseType) { if(superCallMustBeFirst) { if(!funcDecl.bod || !funcDecl.bod.members.length || !((funcDecl.bod.members[0].nodeType == TypeScript.NodeType.Call && (funcDecl.bod.members[0]).target.nodeType == TypeScript.NodeType.Super) || (TypeScript.hasFlag(funcDecl.bod.flags, TypeScript.ASTFlags.StrictMode) && funcDecl.bod.members.length > 1 && funcDecl.bod.members[1].nodeType == TypeScript.NodeType.Call && (funcDecl.bod.members[1]).target.nodeType == TypeScript.NodeType.Super))) { this.checker.errorReporter.simpleError(funcDecl, "If a derived class contains initialized properties or constructor parameter properties, the first statement in the constructor body must be a call to the super constructor"); } } else { if(!this.classConstructorHasSuperCall(funcDecl)) { this.checker.errorReporter.simpleError(funcDecl, "Constructors for derived classes must contain a call to the class's 'super' constructor"); } } } } } if(funcDecl.isMethod() && funcDecl.type.enclosingType) { var enclosingClassNode = null; if(funcDecl.type.enclosingType.symbol.declAST.nodeType == TypeScript.NodeType.FuncDecl) { enclosingClassNode = (funcDecl.type.enclosingType.symbol.declAST).classDecl; } else { if(funcDecl.type.enclosingType.symbol.declAST.nodeType == TypeScript.NodeType.ClassDeclaration) { enclosingClassNode = funcDecl.type.enclosingType.symbol.declAST; } } if(enclosingClassNode) { this.thisClassNode = enclosingClassNode; } } if(fnType.enclosingType) { ; ; var enclosingSym = fnType.symbol.container; if(enclosingSym && enclosingSym.isType() && enclosingSym.getType().isClass()) { enclosingSym = enclosingSym.container; } if(enclosingSym && enclosingSym.declAST && enclosingSym.declAST.nodeType == TypeScript.NodeType.ModuleDeclaration) { this.checker.currentModDecl = enclosingSym.declAST; } } if(funcDecl.unitIndex > 0) { if(this.checker.units && (funcDecl.unitIndex < this.checker.units.length)) { this.checker.locationInfo = this.checker.units[funcDecl.unitIndex]; } else { this.checker.locationInfo = TypeScript.unknownLocationInfo; } } if(fnType.enclosingType) { this.thisType = fnType.enclosingType; } else { this.thisType = prevThisType; } var paramLen = signature.parameters.length; if(!funcDecl.isConstructor && funcDecl.bod && !funcDecl.isSignature()) { var tmpParamScope = this.scope; var ssb = this.scope; if(!funcDecl.isMethod() && funcDecl.returnTypeAnnotation == null) { if(prevScope && funcDecl.name && !funcDecl.name.isMissing()) { var considerSym = prevScope.findAmbient(funcDecl.name.text, false, false); if(considerSym && considerSym.declAST && considerSym.declAST.type) { this.checker.setContextualType(considerSym.declAST.type, false); } } if(this.checker.hasTargetType()) { var candidateTypeContext = this.checker.getTargetTypeContext(); var candidateType = candidateTypeContext.contextualType; if(this.checker.canContextuallyTypeFunction(candidateType, funcDecl, true)) { var candidateSigs = candidateType.construct ? candidateType.construct : candidateType.call; candidateTypeContext.targetSig = candidateSigs.signatures[0]; var candidateParams = candidateTypeContext.targetSig.parameters; targetParams = candidateParams; targetReturnType = candidateTypeContext.targetSig.returnType.type; if(candidateTypeContext.targetSig.declAST) { if(candidateTypeContext.targetSig.declAST.isConstructor) { funcDecl.isTargetTypedAsMethod = true; } else { if(candidateTypeContext.targetSig.declAST.isMethod()) { funcDecl.isTargetTypedAsMethod = true; } } } fgSym.type = candidateTypeContext.contextualType; acceptedContextualType = true; } else { if(candidateType && funcDecl.isAccessor()) { accessorType = candidateType; candidateTypeContext.targetAccessorType = accessorType; } else { this.checker.killCurrentContextualType(); } } } } var paramTable = ssb.valueMembers; this.scope = new TypeScript.SymbolScopeBuilder(paramTable, null, null, null, prevScope, container); for(var p = 0; p < paramLen; p++) { var symbol = signature.parameters[p]; var ast = symbol.declAST; if(this.checker.hasTargetType() && (targetParams && (this.checker.getTargetTypeContext().targetSig.hasVariableArgList || p < targetParams.length))) { var candidateTypeContext = this.checker.getTargetTypeContext(); var hasVarArgList = candidateTypeContext.targetSig.hasVariableArgList; ast.type = hasVarArgList && p >= targetParams.length - 1 ? targetParams[targetParams.length - 1].getType().elementType : targetParams[p].getType(); ast.sym.setType(ast.type); (ast.sym).typeCheckStatus = this.checker.getTypeCheckFinishedStatus(); } else { this.typeCheck(ast); } if(isSetter && accessorType) { ast = this.cast(ast, accessorType); } symbol.container = container; this.checkTypePrivacy(symbol.getType(), container, function (typeName, isModuleName) { return _this.functionArgumentPrivacyErrorReporter(funcDecl, p, symbol, typeName, isModuleName); }); paramTable.publicMembers.add(symbol.name, symbol); } this.scope = tmpParamScope; } else { this.typeCheck(funcDecl.arguments); for(var p = 0; p < paramLen; p++) { signature.parameters[p].parameter.typeLink.type = funcDecl.arguments.members[p].type; this.checkTypePrivacy(signature.parameters[p].getType(), container, function (typeName, isModuleName) { return _this.functionArgumentPrivacyErrorReporter(funcDecl, p, signature.parameters[p], typeName, isModuleName); }); if((funcDecl.arguments.members[p]).parameterPropertySym) { (funcDecl.arguments.members[p]).parameterPropertySym.setType(funcDecl.arguments.members[p].type); } } if((funcDecl.fncFlags & TypeScript.FncFlags.IndexerMember)) { if(!paramLen || paramLen > 1) { this.checker.errorReporter.simpleError(funcDecl, "Index signatures may take one and only one parameter"); } else { if(funcDecl.arguments.members[0].type == this.checker.numberType) { fnType.index.flags |= TypeScript.SignatureFlags.IsNumberIndexer; } else { if(funcDecl.arguments.members[0].type == this.checker.stringType) { fnType.index.flags |= TypeScript.SignatureFlags.IsStringIndexer; } else { this.checker.errorReporter.simpleError(funcDecl.arguments.members[0], "Index signatures may only take 'string' or 'number' as their parameter"); } } } } } if(funcDecl.bod && (!funcDecl.isSignature())) { if(!(funcDecl.isConstructor)) { this.addFormals(container, signature, funcTable); } else { this.addConstructorLocalArgs(funcDecl.type.symbol, funcDecl.arguments, funcTable, TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.ClassMethod)); if(this.thisClassNode && this.thisClassNode.extendsList) { var tmpScope = this.scope; var funcMembers = new TypeScript.ScopedMembers(funcTable); this.scope = new TypeScript.FilteredSymbolScopeBuilder(funcMembers, prevScope, funcDecl.type.symbol, function (sym) { return sym.kind() == TypeScript.SymbolKind.Parameter; }); this.typeCheckBaseCalls(this.thisClassNode.extendsList); this.scope = tmpScope; } } var prevMod = this.checker.currentModDecl; if(funcDecl.type && funcDecl.type.symbol && !funcDecl.isMethod() && funcDecl.type.symbol.declModule) { this.checker.currentModDecl = funcDecl.type.symbol.declModule; } if(acceptedContextualType) { this.checker.setContextualType(null, this.checker.inProvisionalTypecheckMode()); } this.typeCheck(funcDecl.bod); if(acceptedContextualType) { this.checker.unsetContextualType(); } this.checker.currentModDecl = prevMod; if(this.checker.checkControlFlow) { var cfg = funcDecl.buildControlFlow(); if(this.checker.printControlFlowGraph) { cfg.print(this.checker.errorReporter.outfile); } cfg.reportUnreachable(this.checker.errorReporter); if(this.checker.checkControlFlowUseDef) { cfg.useDef(this.checker.errorReporter, funcDecl.type.symbol); } } if(funcDecl.isConstructor) { var fns = funcDecl.scopes; var fnsLen = fns.members.length; var freeVars; var sym; var j = 0; for(; j < fnsLen; j++) { var fn = fns.members[j]; if(!fn.isSignature()) { if(TypeScript.hasFlag(fn.fncFlags, TypeScript.FncFlags.Method) && (!TypeScript.hasFlag(fn.fncFlags, TypeScript.FncFlags.Static))) { this.checkPromoteFreeVars(fn, funcDecl.type.symbol); } } } } } this.scope = prevScope; this.thisFnc = prevFnc; this.thisClassNode = prevClassNode; this.enclosingFncIsMethod = prevMethodStatus; this.thisType = prevThisType; this.checker.locationInfo = prevLocationInfo; this.checker.currentModDecl = prevModDecl; signature.typeCheckStatus = this.checker.getTypeCheckFinishedStatus(); if(funcDecl.returnTypeAnnotation) { this.checkForVoidConstructor(funcDecl.returnTypeAnnotation.type, funcDecl.returnTypeAnnotation); if(signature.returnType.type == null) { this.checker.resolveTypeLink(this.scope, signature.returnType, false); } } else { if(targetReturnType) { signature.returnType.type = targetReturnType; } } if(!(fgSym.flags & TypeScript.SymbolFlags.RecursivelyReferenced) && funcDecl.returnStatementsWithExpressions.length > 0) { var collection = { getLength: function () { return funcDecl.returnStatementsWithExpressions.length; }, setTypeAtIndex: function (index, type) { funcDecl.returnStatementsWithExpressions[index].type = type; }, getTypeAtIndex: function (index) { return funcDecl.returnStatementsWithExpressions[index].type; } }; var bestCommonReturnType = funcDecl.returnStatementsWithExpressions[0].type; bestCommonReturnType = this.checker.findBestCommonType(bestCommonReturnType, null, collection, true); if(bestCommonReturnType) { signature.returnType.type = this.checker.widenType(bestCommonReturnType); } else { for(var i = 0; i < funcDecl.returnStatementsWithExpressions.length; i++) { this.checker.errorReporter.simpleError(funcDecl.returnStatementsWithExpressions[i], "Incompatible return type"); } signature.returnType.type = this.anyType; } } var onlyHasThrow = false; if(signature.returnType.type == null) { if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.HasReturnExpression)) { if(this.checker.styleSettings.implicitAny) { this.checker.errorReporter.styleError(funcDecl, "type implicitly set to 'any'"); } signature.returnType.type = this.anyType; } else { signature.returnType.type = this.voidType; } } else { if(signature.returnType.type == this.nullType || signature.returnType.type == this.checker.undefinedType) { signature.returnType.type = this.anyType; } else { if((signature.returnType.type != this.voidType && signature.returnType.type != this.checker.undefinedType && signature.returnType.type != this.anyType)) { if(!funcDecl.isSignature() && !funcDecl.isConstructor && !TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.HasReturnExpression) && !TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.IsFatArrowFunction)) { onlyHasThrow = (funcDecl.bod.members.length > 0) && (funcDecl.bod.members[0].nodeType == TypeScript.NodeType.Throw); if(!onlyHasThrow) { this.checker.errorReporter.simpleError(funcDecl.returnTypeAnnotation || funcDecl, "Function declared a non-void return type, but has no return expression"); } } this.checkTypePrivacy(signature.returnType.type, container, function (typeName, isModuleName) { return _this.functionReturnTypePrivacyErrorReporter(funcDecl, signature, typeName, isModuleName); }); } } } if(funcDecl.accessorSymbol) { var accessorType = funcDecl.accessorSymbol.getType(); if(!onlyHasThrow && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.GetAccessor) && !TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.HasReturnExpression)) { this.checker.errorReporter.simpleError(funcDecl, "Getters must return a value"); } if(accessorType) { if((TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.GetAccessor) && accessorType != signature.returnType.type) || (funcDecl.arguments.members.length > 0 && accessorType != funcDecl.arguments.members[0].type)) { this.checker.errorReporter.simpleError(funcDecl, "Getter and setter types do not agree"); } } else { if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.GetAccessor)) { funcDecl.accessorSymbol.setType(signature.returnType.type); } else { if(funcDecl.arguments.members.length != 1) { this.checker.errorReporter.simpleError(funcDecl, "Setters may have one and only one argument"); } else { funcDecl.accessorSymbol.setType(funcDecl.arguments.members[0].type); } } } } this.typeCheckOverloadSignatures(fnType, funcDecl); return funcDecl; }; TypeFlow.prototype.typeCheckBases = function (type) { var seenInterface = false; var bases = type.extendsList; var baseLinks = type.extendsTypeLinks; if(bases) { var len = bases.length; if(len > 0) { type.typeFlags |= TypeScript.TypeFlags.HasBaseType; } for(var i = 0; i < len; i++) { if(bases[i] == this.checker.anyType) { baseLinks[i].type = null; var oldErrors = this.checker.errorReporter.getCapturedErrors(); TypeScript.CompilerDiagnostics.assert(oldErrors.length == 0, "There shouldnt be any contextual errors when typechecking base type names"); this.checker.errorReporter.pushToErrorSink = true; bases[i] = this.checker.resolveBaseTypeLink(baseLinks[i], type.containedScope); this.checker.errorReporter.pushToErrorSink = false; this.checker.errorReporter.freeCapturedErrors(); } var base = bases[i]; var baseRef = baseLinks[i].ast; var baseTypeOfObject = base.symbol && base.symbol.name == "Object" && base.symbol.container == this.checker.gloMod; if(baseTypeOfObject) { type.typeFlags |= TypeScript.TypeFlags.HasBaseTypeOfObject; } if(base.isClassInstance()) { if(!(type.isClassInstance())) { this.checker.errorReporter.simpleError(baseRef, "Interface base type must be interface"); } else { if(seenInterface) { this.checker.errorReporter.simpleError(baseRef, "Class may not follow interface as base type"); } } } else { if(base.isModuleType()) { this.checker.errorReporter.simpleError(baseRef, "Types may not be derived from module types"); } else { if(base.members) { if(!seenInterface) { seenInterface = true; } } else { if(!(type.isClassInstance())) { this.checker.errorReporter.simpleError(baseRef, "Interface base type must be interface"); } else { this.checker.errorReporter.simpleError(baseRef, "Base type must be interface or class"); } break; } } } } } }; TypeFlow.prototype.checkMembersImplementInterfaces = function (implementingType) { var instanceType = implementingType.getInstanceType(); if(instanceType.implementsList) { var len = instanceType.implementsList.length; for(var i = 0; i < len; i++) { var interfaceType = instanceType.implementsList[i]; var comparisonInfo = new TypeScript.TypeComparisonInfo(); if(!this.checker.sourceIsSubtypeOfTarget(instanceType, interfaceType, comparisonInfo)) { var emsg = "Class '" + instanceType.getTypeName() + "' declares interface '" + interfaceType.getTypeName() + "' but does not implement it"; if(!comparisonInfo.message) { this.checker.errorReporter.simpleErrorFromSym(instanceType.symbol, emsg); } else { this.checker.errorReporter.simpleErrorFromSym(instanceType.symbol, emsg + ": " + comparisonInfo.message); } } } } }; TypeFlow.prototype.typeCheckBaseCalls = function (bases) { if(bases == null) { return; } var basesLen = bases.members.length; for(var i = 0; i < basesLen; i++) { var baseExpr = bases.members[i]; var baseSymbol = null; if(baseExpr.nodeType == TypeScript.NodeType.Call) { this.typeCheckNew(baseExpr); } } }; TypeFlow.prototype.assertUniqueNamesInBaseTypes = function (names, type, classDecl, checkUnique) { var _this = this; if(type) { if(type.members) { type.members.publicMembers.map(function (key, s, c) { var sym = s; var dup = names.lookup(sym.name); if(dup) { if(checkUnique) { _this.checker.errorReporter.simpleError(classDecl, "duplicate member name in bases for " + classDecl.name.actualText + ": " + type.symbol.name + " and " + dup.container.name + " both contain member with name " + sym.name); } } else { names.add(sym.name, sym); } }, null); } if(type.extendsList) { var len = type.extendsList.length; for(var i = 0; i < len; i++) { if(!(type.extendsList[i].symbol.flags & TypeScript.SymbolFlags.RecursivelyReferenced)) { this.assertUniqueNamesInBaseTypes(names, type.extendsList[i], classDecl, checkUnique); } } } } }; TypeFlow.prototype.checkBaseTypeMemberInheritance = function (derivedType, derivedTypeDecl) { var _this = this; var instanceType = derivedType.getInstanceType(); if(instanceType.extendsList == null) { return; } var len = instanceType.extendsList.length; if(len > 0) { var names = new TypeScript.StringHashTable(); if(instanceType.isClassInstance()) { for(var i = 0; i < len; i++) { this.assertUniqueNamesInBaseTypes(names, instanceType.extendsList[i], derivedTypeDecl, i > 0); } } if(instanceType.members) { instanceType.members.publicMembers.map(function (key, s, c) { var sym = s; for(var j = 0; j < len; j++) { var base = instanceType.extendsList[j]; if(base.memberScope == null) { _this.checker.errorReporter.simpleError(derivedTypeDecl, "Base type '" + base.symbol.name + "' lacks an implementation."); } else { var bSym = base.memberScope.find(sym.name, false, false); if(bSym) { var aType = sym.getType(); var bType = bSym.getType(); if(!(_this.checker.sourceIsSubtypeOfTarget(aType, bType))) { _this.checker.errorReporter.simpleErrorFromSym(sym, "Type of overridden member '" + sym.name + "' is not subtype of original member defined by type '" + bSym.container.name + "'"); } else { if((sym.kind() == TypeScript.SymbolKind.Type) && (bSym.kind() == TypeScript.SymbolKind.Field)) { _this.checker.errorReporter.simpleErrorFromSym(sym, "Cannot override field '" + sym.name + "' with method"); } } } } } }, null); } } }; TypeFlow.prototype.typeCheckClass = function (classDecl) { var typeSymbol = classDecl.type.symbol; if(typeSymbol.typeCheckStatus == TypeScript.TypeCheckStatus.Finished) { return classDecl; } else { if(typeSymbol.typeCheckStatus == TypeScript.TypeCheckStatus.Started) { return classDecl; } else { typeSymbol.typeCheckStatus = TypeScript.TypeCheckStatus.Started; this.checker.addStartedPTO(typeSymbol); } } var prevScope = this.scope; var svClassNode = this.thisClassNode; this.thisClassNode = classDecl; var classType = classDecl.type; this.typeCheckBases(classType.instanceType); this.typeCheckBaseListPrivacy(classDecl.extendsList, typeSymbol, true); this.typeCheckBaseListPrivacy(classDecl.implementsList, typeSymbol, false); var prevThisType = this.thisType; this.thisType = classType.instanceType; this.scope = classType.instanceType.containedScope; if(classDecl.constructorDecl) { this.scope = classType.instanceType.constructorScope; var ssb = this.scope; var funcTable = ssb.valueMembers.allMembers; this.addConstructorLocalArgs(classDecl.constructorDecl.type.symbol, classDecl.constructorDecl.arguments, funcTable, true); } this.typeCheck(classDecl.members); typeSymbol.typeCheckStatus = TypeScript.TypeCheckStatus.Finished; this.checkBaseTypeMemberInheritance(classType, classDecl); this.checkMembersImplementInterfaces(classType); this.typeCheckOverloadSignatures(classType, classDecl); this.typeCheckOverloadSignatures(classType.instanceType, classDecl); if(!classDecl.constructorDecl) { if(classDecl.extendsList && classDecl.extendsList.members.length && classDecl.extendsList.members[0].type && classDecl.extendsList.members[0].type.symbol.type.isClass()) { TypeScript.cloneParentConstructGroupForChildType(classDecl.type, classDecl.extendsList.members[0].type.symbol.type); } } this.thisType = prevThisType; this.thisClassNode = svClassNode; this.scope = prevScope; return classDecl; }; TypeFlow.prototype.typeCheckOverloadSignatures = function (type, ast) { if(type.call) { type.call.typeCheck(this.checker, ast, type.construct != null); } if(type.construct) { type.construct.typeCheck(this.checker, ast, false); } if(type.index) { type.index.typeCheck(this.checker, ast, false); } }; TypeFlow.prototype.typeCheckInterface = function (interfaceDecl) { this.typeCheckBases(interfaceDecl.type); this.typeCheckBaseListPrivacy(interfaceDecl.extendsList, interfaceDecl.type.symbol, true); this.typeCheck(interfaceDecl.members); this.checkBaseTypeMemberInheritance(interfaceDecl.type, interfaceDecl); if(interfaceDecl.extendsList) { for(var i = 0; i < interfaceDecl.extendsList.members.length; i++) { if(interfaceDecl.extendsList.members[i].type.call) { if(interfaceDecl.type.call) { interfaceDecl.type.call.signatures = interfaceDecl.type.call.signatures.concat(interfaceDecl.extendsList.members[i].type.call.signatures); } else { interfaceDecl.type.call = interfaceDecl.extendsList.members[i].type.call; } } if(interfaceDecl.extendsList.members[i].type.construct) { if(interfaceDecl.type.construct) { interfaceDecl.type.construct.signatures = interfaceDecl.type.construct.signatures.concat(interfaceDecl.extendsList.members[i].type.construct.signatures); } else { interfaceDecl.type.construct = interfaceDecl.extendsList.members[i].type.construct; } } if(interfaceDecl.extendsList.members[i].type.index) { if(interfaceDecl.type.index) { interfaceDecl.type.index.signatures = interfaceDecl.type.index.signatures.concat(interfaceDecl.extendsList.members[i].type.index.signatures); } else { interfaceDecl.type.index = interfaceDecl.extendsList.members[i].type.index; } } } } return interfaceDecl; }; TypeFlow.prototype.typeCheckImportDecl = function (importDecl) { var mod = importDecl.alias.type; var sym = null; var prevInImportTC = this.inImportTypeCheck; this.inImportTypeCheck = true; this.typeCheck(importDecl.alias); mod = importDecl.alias.type; if(mod == null) { this.checker.errorReporter.simpleError(importDecl.alias, "Could not resolve module alias '" + importDecl.id.actualText + "'"); mod = this.checker.anyType; (importDecl.id.sym).type = mod; } importDecl.id.type = mod; sym = mod.symbol; if(!mod.isModuleType()) { this.checker.errorReporter.simpleError(importDecl.alias, "A module cannot be aliased to a non-module type"); } else { sym.type = mod; if(this.checker.typeFlow.currentScript && this.checker.typeFlow.currentScript.topLevelMod && this.checker.typeFlow.currentScript.topLevelMod.mod) { this.checker.typeFlow.currentScript.topLevelMod.mod.importedModules.push(importDecl); } (importDecl.id.sym).type = mod; if(mod.symbol && mod.symbol.declAST) { (mod.symbol.declAST).modFlags &= ~TypeScript.ModuleFlags.ShouldEmitModuleDecl; } } this.inImportTypeCheck = prevInImportTC; return importDecl; }; TypeFlow.prototype.typeCheckModule = function (moduleDecl) { if(!moduleDecl.mod) { return moduleDecl; } if(this.currentScript) { this.currentScript.requiresGlobal = true; } var mod = moduleDecl.mod; var sym = null; var prevScope = this.scope; var prevThisType = this.thisType; var prevCurrentModDecl = this.checker.currentModDecl; this.checker.currentModDecl = moduleDecl; this.thisType = null; this.scope = mod.containedScope; this.typeCheck(moduleDecl.members); sym = mod.symbol; this.checker.currentModDecl = prevCurrentModDecl; this.thisType = prevThisType; this.scope = prevScope; moduleDecl.type = mod; if(sym) { sym.typeCheckStatus = TypeScript.TypeCheckStatus.Finished; } return moduleDecl; }; TypeFlow.prototype.typeCheckFor = function (forStmt) { forStmt.init = this.typeCheck(forStmt.init); this.nestingLevel++; forStmt.cond = this.typeCheck(forStmt.cond); this.typeCheckCondExpr(forStmt.cond); forStmt.incr = this.typeCheck(forStmt.incr); this.nestingLevel--; forStmt.body = this.typeCheck(forStmt.body); this.typeCheckCompoundStmtBlock(forStmt.body, "for statement"); forStmt.type = this.voidType; return forStmt; }; TypeFlow.prototype.typeCheckWith = function (withStmt) { if(this.checker.errorsOnWith) { this.checker.errorReporter.simpleError(withStmt.expr, "All symbols within a 'with' block will be typed as 'any'"); } withStmt.expr = this.typeCheck(withStmt.expr); this.checker.inWith = true; withStmt.body = this.typeCheck(withStmt.body); this.typeCheckCompoundStmtBlock(withStmt.body, "with statement"); this.checker.inWith = false; return withStmt; }; TypeFlow.prototype.typeCheckForIn = function (forInStmt) { forInStmt.obj = this.typeCheck(forInStmt.obj); forInStmt.lval = this.cast(this.typeCheck(forInStmt.lval), this.checker.stringType); if(forInStmt.lval.nodeType == TypeScript.NodeType.VarDecl) { var varDecl = forInStmt.lval; if(varDecl.typeExpr) { this.checker.errorReporter.simpleError(varDecl, "Variable declarations for for/in expressions may not contain a type annotation"); } if(varDecl.sym) { varDecl.sym.setType(this.checker.stringType); } } forInStmt.body = this.typeCheck(forInStmt.body); this.typeCheckCompoundStmtBlock(forInStmt.body, "for in statement"); return forInStmt; }; TypeFlow.prototype.typeCheckWhile = function (whileStmt) { whileStmt.cond = this.typeCheck(whileStmt.cond); this.typeCheckCondExpr(whileStmt.cond); whileStmt.body = this.typeCheck(whileStmt.body); this.typeCheckCompoundStmtBlock(whileStmt.body, "while statement"); whileStmt.type = this.voidType; return whileStmt; }; TypeFlow.prototype.typeCheckDoWhile = function (doWhileStmt) { doWhileStmt.cond = this.typeCheck(doWhileStmt.cond); this.typeCheckCondExpr(doWhileStmt.cond); doWhileStmt.body = this.typeCheck(doWhileStmt.body); this.typeCheckCompoundStmtBlock(doWhileStmt.body, "do while statement"); doWhileStmt.type = this.voidType; return doWhileStmt; }; TypeFlow.prototype.typeCheckCondExpr = function (cond) { if(this.checker.styleSettings.assignmentInCond) { if((cond !== null) && (cond.nodeType >= TypeScript.NodeType.Asg) && (cond.nodeType <= TypeScript.NodeType.LastAsg)) { this.checker.errorReporter.simpleError(cond, "top-level assignment statement in conditional expression"); } } }; TypeFlow.prototype.typeCheckCompoundStmtBlock = function (stmts, stmtType) { if(this.checker.styleSettings.blockInCompoundStmt && stmts) { if(stmts.nodeType != TypeScript.NodeType.Block) { this.checker.errorReporter.styleError(stmts, stmtType + " requires a block"); } } }; TypeFlow.prototype.typeCheckIf = function (ifStmt) { ifStmt.cond = this.typeCheck(ifStmt.cond); this.typeCheckCondExpr(ifStmt.cond); ifStmt.thenBod = this.typeCheck(ifStmt.thenBod); ifStmt.elseBod = this.typeCheck(ifStmt.elseBod); this.typeCheckCompoundStmtBlock(ifStmt.thenBod, "if statement"); this.typeCheckCompoundStmtBlock(ifStmt.elseBod, "if statement"); ifStmt.type = this.voidType; return ifStmt; }; TypeFlow.prototype.typeFromAccessorFuncDecl = function (funcDecl) { if(!funcDecl.isAccessor()) { return null; } if(TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.GetAccessor)) { return funcDecl.type.call.signatures[0].returnType.type; } else { return funcDecl.type.call.signatures[0].parameters[0].getType(); } }; TypeFlow.prototype.typeCheckObjectLit = function (objectLit) { var resultType = new TypeScript.Type(); resultType.symbol = new TypeScript.TypeSymbol(this.checker.anon, objectLit.minChar, objectLit.limChar - objectLit.minChar, this.checker.locationInfo.unitIndex, resultType); resultType.members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); resultType.memberScope = new TypeScript.SymbolTableScope(resultType.members, null, null, null, null); var aggScope = new TypeScript.SymbolAggregateScope(resultType.symbol); aggScope.addParentScope(resultType.memberScope); aggScope.addParentScope(this.scope); resultType.containedScope = aggScope; var memberDecls = objectLit.operand; var prevThisType = this.thisType; var acceptTargetType = false; var targetType = null; if(this.checker.hasTargetType()) { targetType = this.checker.getTargetTypeContext().contextualType; if(targetType && targetType.symbol && !this.checker.typeStatusIsFinished(targetType.symbol.typeCheckStatus)) { if(targetType.symbol.declAST) { this.typeCheck(targetType.symbol.declAST); } } acceptTargetType = true; } if(memberDecls) { for(var i = 0, len = memberDecls.members.length; i < len; i++) { var binex = memberDecls.members[i]; var id = binex.operand1; var text; var targetMember = null; var fieldSymbol = null; if(id.nodeType == TypeScript.NodeType.Name) { text = (id).text; } else { if(id.nodeType == TypeScript.NodeType.QString) { var idText = (id).text; text = idText.substring(1, idText.length - 1); } else { this.checker.errorReporter.simpleError(objectLit, "malformed object literal"); resultType = this.anyType; break; } } if(acceptTargetType && targetType.memberScope) { targetMember = targetType.memberScope.find(text, false, false); } if(binex.operand2.nodeType == TypeScript.NodeType.FuncDecl && (binex.operand2).isAccessor()) { var funcDecl = binex.operand2; var accessorSym = resultType.members.publicMembers.lookup(text); accessorSym = this.checker.createAccessorSymbol(funcDecl, accessorSym, resultType, true, false, resultType.memberScope, null); funcDecl.accessorSymbol = accessorSym; fieldSymbol = accessorSym; if(id.nodeType == TypeScript.NodeType.Name) { (id).sym = accessorSym; } } this.checker.typeCheckWithContextualType(acceptTargetType && targetMember ? targetMember.getType() : null, false, acceptTargetType, binex.operand2); if(acceptTargetType && targetMember) { if((binex.operand2.type == this.anyType || this.checker.sourceIsAssignableToTarget(binex.operand2.type, targetMember.getType())) || (binex.operand2.nodeType == TypeScript.NodeType.FuncDecl && (binex.operand2).isAccessor() && this.typeFromAccessorFuncDecl(binex.operand2) == targetMember.getType())) { binex.operand1.type = targetMember.getType(); } } else { binex.operand2.type = binex.operand2.type == this.checker.undefinedType ? this.anyType : binex.operand2.type; } if(fieldSymbol == null) { var memberType = binex.operand2.type; var field = new TypeScript.ValueLocation(); fieldSymbol = new TypeScript.FieldSymbol(text, id.minChar, this.checker.locationInfo.unitIndex, true, field); fieldSymbol.flags |= TypeScript.SymbolFlags.Property; field.symbol = fieldSymbol; fieldSymbol.typeCheckStatus = this.checker.getTypeCheckFinishedStatus(); field.typeLink = new TypeScript.TypeLink(); field.typeLink.type = memberType; resultType.members.publicMembers.add(text, fieldSymbol); } fieldSymbol.isObjectLitField = true; } } this.thisType = prevThisType; objectLit.type = resultType; if(targetType) { objectLit.targetType = targetType; } }; TypeFlow.prototype.typeCheckArrayLit = function (arrayLit) { var elements = arrayLit.operand; var elementType = this.anyType; var targetElementType = null; var comparisonInfo = new TypeScript.TypeComparisonInfo(); comparisonInfo.onlyCaptureFirstError = true; if(this.checker.hasTargetType()) { var targetType = this.checker.getTargetTypeContext().contextualType; if(targetType.elementType) { targetElementType = targetType.elementType; } } if(elements) { var prevInArrayElemTypeCheck = this.inArrayElementTypeCheck; this.inArrayElementTypeCheck = true; this.checker.typeCheckWithContextualType(targetElementType, this.checker.inProvisionalTypecheckMode(), targetElementType != null, elements); this.inArrayElementTypeCheck = prevInArrayElemTypeCheck; elementType = elements.members[0].type; var collection = { getLength: function () { return elements.members.length; }, setTypeAtIndex: function (index, type) { elements.members[index].type = type; }, getTypeAtIndex: function (index) { return elements.members[index].type; } }; elementType = this.checker.findBestCommonType(elementType, targetElementType, collection, false, comparisonInfo); if(elementType == this.checker.undefinedType || (!prevInArrayElemTypeCheck && elementType == this.nullType)) { elementType = this.anyType; } } if(!elementType) { var emsg = "Incompatible types in array literal expression"; if(!comparisonInfo.message) { this.checker.errorReporter.simpleError(arrayLit, emsg); } else { this.checker.errorReporter.simpleError(arrayLit, emsg + ": " + comparisonInfo.message); } elementType = this.anyType; } else { if(targetElementType) { if(this.checker.sourceIsAssignableToTarget(elementType, targetElementType)) { elementType = targetElementType; } } } arrayLit.type = this.checker.makeArrayType(elementType); }; TypeFlow.prototype.checkForVoidConstructor = function (type, ast) { if(type && type.construct && type.construct.signatures.length > 0) { for(var i = 0; i < type.construct.signatures.length; i++) { if(type.construct.signatures[i].returnType.type == this.checker.voidType) { this.checker.errorReporter.simpleError(ast, "Constructors may not have a return type of 'void'"); break; } } } }; TypeFlow.prototype.typeCheckReturn = function (returnStmt) { if(this.thisFnc) { var targetType = null; if(this.checker.hasTargetType()) { var tcContext = this.checker.getTargetTypeContext(); var accessorType = tcContext.targetAccessorType; if(accessorType) { targetType = accessorType; } else { var targetSig = this.checker.getTargetTypeContext().targetSig; if(targetSig && targetSig.returnType.type != this.voidType) { targetType = targetSig.returnType.type; } } } if(returnStmt.returnExpression) { this.thisFnc.fncFlags |= TypeScript.FncFlags.HasReturnExpression; if(targetType == null && this.thisFnc.returnTypeAnnotation && this.thisFnc.returnTypeAnnotation.type && this.thisFnc.returnTypeAnnotation.type != this.voidType) { targetType = this.thisFnc.returnTypeAnnotation.type; } this.checker.typeCheckWithContextualType(targetType, this.checker.inProvisionalTypecheckMode(), targetType != null, returnStmt.returnExpression); var expectedReturnType = (this.thisFnc.returnTypeAnnotation && this.thisFnc.returnTypeAnnotation.type) ? this.thisFnc.returnTypeAnnotation.type : targetType; if(expectedReturnType) { if(expectedReturnType == this.voidType && returnStmt.returnExpression.type != this.voidType) { this.checker.errorReporter.simpleError(returnStmt, "Return with value expression in void function"); returnStmt.type = returnStmt.returnExpression.type; } else { returnStmt.returnExpression = this.cast(returnStmt.returnExpression, expectedReturnType); returnStmt.type = expectedReturnType; } } else { if(targetType) { if(returnStmt.returnExpression.type != this.voidType) { returnStmt.returnExpression = this.cast(returnStmt.returnExpression, targetType); } else { returnStmt.returnExpression.type = targetType; } } returnStmt.type = returnStmt.returnExpression.type; } this.thisFnc.returnStatementsWithExpressions[this.thisFnc.returnStatementsWithExpressions.length] = returnStmt; } else { returnStmt.type = targetType == null ? this.checker.voidType : targetType; } } return returnStmt; }; TypeFlow.prototype.typeCheckInstOf = function (ast) { var binex = ast; binex.operand1 = this.typeCheck(binex.operand1); binex.operand2 = this.typeCheck(binex.operand2); if(!((binex.operand1.type == this.checker.anyType || this.checker.sourceIsSubtypeOfTarget(binex.operand1.type, this.objectInterfaceType)) && (binex.operand2.type == this.anyType || this.checker.sourceIsSubtypeOfTarget(binex.operand2.type, this.functionInterfaceType)))) { this.checker.errorReporter.simpleError(ast, "The instanceof operator requires the left operand to be of type Any or an object type, and the right operand to be of type Any or a subtype of the Function interface type"); } binex.type = this.booleanType; return binex; }; TypeFlow.prototype.typeCheckCommaOperator = function (ast) { var binex = ast; binex.operand1 = this.typeCheck(binex.operand1); binex.operand2 = this.typeCheck(binex.operand2); binex.type = binex.operand2.type; return binex; }; TypeFlow.prototype.typeCheckLogOr = function (binex) { binex.operand1 = this.typeCheck(binex.operand1); binex.operand2 = this.typeCheck(binex.operand2); var leftType = binex.operand1.type; var rightType = binex.operand2.type; if(leftType == this.checker.anyType || rightType == this.checker.anyType) { binex.type = this.checker.anyType; } else { if(leftType == this.checker.booleanType) { if(rightType == this.checker.booleanType) { binex.type = this.checker.booleanType; } else { binex.type = this.checker.anyType; } } else { if(leftType == this.checker.numberType) { if(rightType == this.checker.numberType) { binex.type = this.checker.numberType; } else { binex.type = this.checker.anyType; } } else { if(leftType == this.checker.stringType) { if(rightType == this.checker.stringType) { binex.type = this.checker.stringType; } else { binex.type = this.checker.anyType; } } else { if(this.checker.sourceIsSubtypeOfTarget(leftType, rightType)) { binex.type = rightType; } else { if(this.checker.sourceIsSubtypeOfTarget(rightType, leftType)) { binex.type = leftType; } else { binex.type = this.checker.anyType; } } } } } } return binex; }; TypeFlow.prototype.typeCheckLogAnd = function (binex) { binex.operand1 = this.typeCheck(binex.operand1); binex.operand2 = this.typeCheck(binex.operand2); binex.type = binex.operand2.type; return binex; }; TypeFlow.prototype.tryAddCandidates = function (signature, actuals, exactCandidates, conversionCandidates, comparisonInfo) { var lowerBound = signature.nonOptionalParameterCount; var upperBound = signature.parameters.length; var formalLen = lowerBound; var acceptable = false; if((actuals.length >= lowerBound) && (signature.hasVariableArgList || actuals.length <= upperBound)) { formalLen = (signature.hasVariableArgList ? signature.parameters.length : actuals.length); acceptable = true; } var repeatType = null; if(acceptable || signature.hasVariableArgList) { if(signature.hasVariableArgList) { formalLen -= 1; repeatType = (signature.parameters[formalLen]).parameter.typeLink.type; repeatType = repeatType.elementType; acceptable = actuals.length >= formalLen; } var len = actuals.length; var exact = acceptable; var convert = acceptable; for(var i = 0; i < len; i++) { var typeA; if(i < formalLen) { typeA = (signature.parameters[i]).parameter.typeLink.type; } else { typeA = repeatType; } var typeB = actuals[i]; if(!typeA || !typeB || !(this.checker.typesAreIdentical(typeA, typeB))) { exact = false; } if(!this.checker.sourceIsAssignableToTarget(typeB, typeA, comparisonInfo)) { convert = false; } if(!(exact || convert)) { break; } } if(exact) { exactCandidates[exactCandidates.length] = signature; } else { if(convert && (exactCandidates.length == 0)) { conversionCandidates[conversionCandidates.length] = signature; } } } }; TypeFlow.prototype.resolveOverload = function (application, group) { var rd = this.resolutionDataCache.getResolutionData(); var actuals = rd.actuals; var exactCandidates = rd.exactCandidates; var conversionCandidates = rd.conversionCandidates; var candidate = null; var hasOverloads = group.signatures.length > 1; var comparisonInfo = new TypeScript.TypeComparisonInfo(); var args = null; var target = null; if(application.nodeType == TypeScript.NodeType.Call || application.nodeType == TypeScript.NodeType.New) { var callEx = application; args = callEx.arguments; target = callEx.target; if(callEx.arguments) { var len = callEx.arguments.members.length; for(var i = 0; i < len; i++) { actuals[i] = callEx.arguments.members[i].type; } } } else { if(application.nodeType == TypeScript.NodeType.Index) { var binExp = application; target = binExp.operand1; args = new TypeScript.ASTList(); args.members[0] = binExp.operand2; actuals[0] = binExp.operand2.type; } } for(var j = 0, groupLen = group.signatures.length; j < groupLen; j++) { var signature = group.signatures[j]; if(hasOverloads && signature == group.definitionSignature && !this.checker.canCallDefinitionSignature) { continue; } if(!signature.returnType.type && signature.declAST && (signature.typeCheckStatus != TypeScript.TypeCheckStatus.Finished)) { this.typeCheckFunction(signature.declAST); } this.tryAddCandidates(signature, actuals, exactCandidates, conversionCandidates, comparisonInfo); } if(exactCandidates.length == 0) { var applicableCandidates = this.checker.getApplicableSignatures(conversionCandidates, args, comparisonInfo); if(applicableCandidates.length > 0) { var candidateInfo = this.checker.findMostApplicableSignature(applicableCandidates, args); if(candidateInfo.ambiguous) { this.checker.errorReporter.simpleError(target, "Ambiguous call expression - could not choose overload"); } candidate = candidateInfo.sig; } else { var emsg = "Supplied parameters do not match any signature of call target"; if(comparisonInfo.message) { this.checker.errorReporter.simpleError(target, emsg + ":\n\t" + comparisonInfo.message); } else { this.checker.errorReporter.simpleError(target, emsg); } } } else { if(exactCandidates.length > 1) { var applicableSigs = []; for(var i = 0; i < exactCandidates.length; i++) { applicableSigs[i] = { signature: exactCandidates[i], hadProvisionalErrors: false }; } var candidateInfo = this.checker.findMostApplicableSignature(applicableSigs, args); if(candidateInfo.ambiguous) { this.checker.errorReporter.simpleError(target, "Ambiguous call expression - could not choose overload"); } candidate = candidateInfo.sig; } else { candidate = exactCandidates[0]; } } this.resolutionDataCache.returnResolutionData(rd); return candidate; }; TypeFlow.prototype.typeCheckNew = function (ast) { var callEx = ast; callEx.target = this.typeCheck(callEx.target); var target = callEx.target; if(target.type.construct || target.type.call) { this.preTypeCheckCallArgs(callEx.arguments); } else { callEx.arguments = this.typeCheck(callEx.arguments); } if(target.type == this.anyType) { callEx.type = this.anyType; callEx.arguments = this.typeCheck(callEx.arguments); } else { if(target.type.construct) { var signature = this.resolveOverload(callEx, target.type.construct); if(signature == null) { callEx.type = this.anyType; } else { if(signature.returnType.type == this.voidType) { callEx.type = this.anyType; callEx.signature = signature; } else { callEx.type = signature.returnType.type; callEx.signature = signature; } } } else { if(target.type.call) { var signature = this.resolveOverload(callEx, target.type.call); if(signature == null) { callEx.type = this.anyType; } else { if((signature.returnType.type == this.voidType) || (signature.returnType.type == this.anyType)) { callEx.type = this.anyType; callEx.signature = signature; } else { this.checker.errorReporter.simpleError(callEx.target, "new expression only valid on constructors"); } } } else { if(target.type.elementType) { callEx.type = target.type; } else { this.checker.errorReporter.invalidCall(callEx, callEx.nodeType, this.scope); callEx.type = this.anyType; } } } } this.postTypeCheckCallArgs(callEx); return callEx; }; TypeFlow.prototype.preTypeCheckCallArgs = function (args) { if(!args) { return; } for(var i = 0; i < args.members.length; i++) { switch(args.members[i].nodeType) { case TypeScript.NodeType.FuncDecl: case TypeScript.NodeType.ObjectLit: case TypeScript.NodeType.ArrayLit: { continue; } default: { this.typeCheck(args.members[i]); break; } } } }; TypeFlow.prototype.postTypeCheckCallArgs = function (callEx) { var acceptedTargetType = false; var i = 0; if(callEx.target && callEx.target.type && callEx.signature && callEx.arguments) { var sig = callEx.signature; if(sig && callEx.arguments.members.length >= sig.nonOptionalParameterCount) { acceptedTargetType = true; var targetType = null; var nonVarArgFormalParamLength = sig.hasVariableArgList ? sig.parameters.length - 1 : sig.parameters.length; var nonVarArgActualParamLength = callEx.arguments.members.length < nonVarArgFormalParamLength ? callEx.arguments.members.length : nonVarArgFormalParamLength; for(i = 0; i < nonVarArgActualParamLength; i++) { targetType = sig.parameters[i].getType(); switch(callEx.arguments.members[i].nodeType) { case TypeScript.NodeType.FuncDecl: case TypeScript.NodeType.ObjectLit: case TypeScript.NodeType.ArrayLit: { this.checker.typeCheckWithContextualType(targetType, this.checker.inProvisionalTypecheckMode(), !sig.parameters[i].declAST.isParenthesized, callEx.arguments.members[i]); break; } } } if(sig.hasVariableArgList) { var varArgParamIndex = sig.nonOptionalParameterCount - 1; targetType = sig.parameters[varArgParamIndex].getType(); if(targetType) { targetType = targetType.elementType; } var isParenthesized = !sig.parameters[varArgParamIndex].declAST.isParenthesized; for(i = nonVarArgActualParamLength; i < callEx.arguments.members.length; i++) { switch(callEx.arguments.members[i].nodeType) { case TypeScript.NodeType.FuncDecl: case TypeScript.NodeType.ObjectLit: case TypeScript.NodeType.ArrayLit: { this.checker.typeCheckWithContextualType(targetType, this.checker.inProvisionalTypecheckMode(), isParenthesized, callEx.arguments.members[i]); break; } } } } } } if(!acceptedTargetType && callEx.arguments) { this.checker.killCurrentContextualType(); for(i = 0; i < callEx.arguments.members.length; i++) { switch(callEx.arguments.members[i].nodeType) { case TypeScript.NodeType.FuncDecl: case TypeScript.NodeType.ObjectLit: case TypeScript.NodeType.ArrayLit: { this.typeCheck(callEx.arguments.members[i]); break; } default: { continue; } } } } }; TypeFlow.prototype.typeCheckCall = function (ast) { var callEx = ast; if(this.checker.styleSettings.newMustBeUsed && (ast.nodeType == TypeScript.NodeType.New)) { if(TypeScript.hasFlag(ast.flags, TypeScript.ASTFlags.IsStatement)) { this.checker.errorReporter.styleError(ast, "use of new expression as a statement"); } } else { if((!this.checker.styleSettings.evalOK) && (ast.nodeType == TypeScript.NodeType.Call)) { if((callEx.target.nodeType == TypeScript.NodeType.Name) && ((callEx.target).text == "eval")) { this.checker.errorReporter.styleError(callEx, "eval not permitted"); } } } if(callEx.target.nodeType == TypeScript.NodeType.FuncDecl) { (callEx.target).isInlineCallLiteral = true; } var prevInSuperCall = this.inSuperCall; if(callEx.target.nodeType == TypeScript.NodeType.Super) { this.inSuperCall = true; } callEx.target = this.typeCheck(callEx.target); this.preTypeCheckCallArgs(callEx.arguments); var target = callEx.target; if((target.type == null) || (target.type == this.anyType) || (this.functionInterfaceType && target.type == this.functionInterfaceType)) { callEx.type = this.anyType; } else { var fnType = target.type; if(fnType.call) { var signature = this.resolveOverload(callEx, fnType.call); if(signature == null) { callEx.type = this.anyType; } else { callEx.type = signature.returnType.type; callEx.signature = signature; } } else { if(callEx.target.nodeType == TypeScript.NodeType.Super && this.thisFnc && this.thisFnc.isConstructor && TypeScript.hasFlag(this.thisFnc.fncFlags, TypeScript.FncFlags.ClassMethod)) { var signature = fnType.symbol.type.construct ? this.resolveOverload(callEx, fnType.symbol.type.construct) : null; if(signature == null) { callEx.type = this.anyType; } else { callEx.flags |= TypeScript.ASTFlags.ClassBaseConstructorCall; callEx.type = signature.returnType.type; callEx.signature = signature; } } else { callEx.type = this.anyType; this.checker.errorReporter.invalidCall(callEx, callEx.nodeType, this.scope); } } } this.postTypeCheckCallArgs(callEx); this.inSuperCall = prevInSuperCall; return callEx; }; TypeFlow.prototype.assignScopes = function (ast) { var script = ast; this.checker.locationInfo = script.locationInfo; var globalChain = new ScopeChain(this.checker.gloMod, null, this.globalScope); var context = new TypeScript.AssignScopeContext(globalChain, this, [ this.checker.currentModDecl ]); TypeScript.getAstWalkerFactory().walk(ast, TypeScript.preAssignScopes, TypeScript.postAssignScopes, null, context); }; TypeFlow.prototype.findMemberScope = function (enclosingScopeContext, matchFlag) { var enclosingScope = enclosingScopeContext.getScope(); var pos = enclosingScopeContext.pos - enclosingScopeContext.getScriptFragmentPosition(); var scriptFragment = enclosingScopeContext.getScriptFragment(); var memContext = new TypeScript.MemberScopeContext(this, pos, matchFlag); memContext.scope = enclosingScope; if(scriptFragment.nodeType == TypeScript.NodeType.Name) { return scriptFragment.type.getMemberScope(this); } else { TypeScript.getAstWalkerFactory().walk(scriptFragment, TypeScript.preFindMemberScope, null, null, memContext); if(memContext.ast && enclosingScopeContext.enclosingClassDecl && memContext.ast.type == enclosingScopeContext.enclosingClassDecl.type.instanceType) { enclosingScopeContext.publicsOnly = false; } if(memContext.type) { return memContext.type.getMemberScope(this); } else { return null; } } }; TypeFlow.prototype.findMemberScopeAt = function (enclosingScopeContext) { return this.findMemberScope(enclosingScopeContext, TypeScript.ASTFlags.DotLHS); }; TypeFlow.prototype.findMemberScopeAtFullAst = function (enclosingScopeContext) { var matchFlag = TypeScript.ASTFlags.DotLHS; var pos = enclosingScopeContext.pos; var astResult = null; var preFindMemberScopeFullAst = function (ast, parent, walker) { if(TypeScript.isValidAstNode(ast)) { if(TypeScript.hasFlag(ast.flags, matchFlag) && (pos == ast.limChar || (pos - 1) == ast.limChar)) { astResult = ast; walker.options.stopWalk(); } walker.options.goChildren = (ast.minChar <= pos) && (pos <= ast.limChar); } return ast; }; var preFindMemberScopeFullAstFuzy = function (ast, parent, walker) { if(TypeScript.isValidAstNode(ast)) { if(TypeScript.hasFlag(ast.flags, matchFlag) && ((ast.minChar < pos) && (pos <= ast.limChar))) { astResult = ast; } walker.options.goChildren = (ast.minChar <= pos) && (pos <= ast.limChar); } return ast; }; TypeScript.getAstWalkerFactory().walk(enclosingScopeContext.script, preFindMemberScopeFullAst); if(astResult == null) { TypeScript.getAstWalkerFactory().walk(enclosingScopeContext.script, preFindMemberScopeFullAstFuzy); } if(astResult && enclosingScopeContext.enclosingClassDecl && astResult.type == enclosingScopeContext.enclosingClassDecl.type.instanceType) { enclosingScopeContext.publicsOnly = false; } if(astResult && astResult.type) { return astResult.type.getMemberScope(this); } else { return null; } }; return TypeFlow; })(); TypeScript.TypeFlow = TypeFlow; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { (function (Primitive) { Primitive._map = []; Primitive.None = 0; Primitive.Void = 1; Primitive.Double = 2; Primitive.String = 4; Primitive.Boolean = 8; Primitive.Any = 16; Primitive.Null = 32; Primitive.Undefined = 64; })(TypeScript.Primitive || (TypeScript.Primitive = {})); var Primitive = TypeScript.Primitive; var MemberName = (function () { function MemberName() { this.prefix = ""; this.suffix = ""; } MemberName.prototype.isString = function () { return false; }; MemberName.prototype.isArray = function () { return false; }; MemberName.prototype.toString = function () { return MemberName.memberNameToString(this); }; MemberName.memberNameToString = function memberNameToString(memberName) { var result = memberName.prefix; if(memberName.isString()) { result += (memberName).text; } else { var ar = memberName; for(var index = 0; index < ar.entries.length; index++) { result += MemberName.memberNameToString(ar.entries[index]); result += ar.delim; } } result += memberName.suffix; return result; } MemberName.create = function create(arg1, arg2, arg3) { if(typeof arg1 == "string") { return new MemberNameString(arg1); } else { var result = new MemberNameArray(); if(arg2) { result.prefix = arg2; } if(arg3) { result.suffix = arg3; } result.entries.push(arg1); return result; } } return MemberName; })(); TypeScript.MemberName = MemberName; var MemberNameString = (function (_super) { __extends(MemberNameString, _super); function MemberNameString(text) { _super.call(this); this.text = text; } MemberNameString.prototype.isString = function () { return true; }; return MemberNameString; })(MemberName); TypeScript.MemberNameString = MemberNameString; var MemberNameArray = (function (_super) { __extends(MemberNameArray, _super); function MemberNameArray() { _super.apply(this, arguments); this.delim = ""; this.entries = []; } MemberNameArray.prototype.isArray = function () { return true; }; MemberNameArray.prototype.add = function (entry) { this.entries.push(entry); }; MemberNameArray.prototype.addAll = function (entries) { for(var i = 0; i < entries.length; i++) { this.entries.push(entries[i]); } }; return MemberNameArray; })(MemberName); TypeScript.MemberNameArray = MemberNameArray; var currentTypeID = -1; var Type = (function () { function Type() { this.typeID = currentTypeID++; this.construct = null; this.call = null; this.index = null; this.passTypeCreated = TypeScript.CompilerDiagnostics.analysisPass; this.primitiveTypeClass = Primitive.None; this.typeFlags = TypeScript.TypeFlags.None; } Type.prototype.baseClass = function () { if(this.extendsList && (this.extendsList.length > 0)) { return this.extendsList[0]; } else { return null; } }; Type.prototype.getArrayBase = function (arrInstType, checker) { return this.arrayCache.specialize(arrInstType, checker); }; Type.prototype.isClass = function () { return this.instanceType != null; }; Type.prototype.isArray = function () { return this.elementType != null; }; Type.prototype.isClassInstance = function () { return this.symbol && !this.elementType && (this.symbol).type.isClass(); }; Type.prototype.getInstanceType = function () { if(this.isClass()) { return this.instanceType; } else { return this; } }; Type.prototype.hasImplementation = function () { return TypeScript.hasFlag(this.typeFlags, TypeScript.TypeFlags.HasImplementation); }; Type.prototype.setHasImplementation = function () { this.typeFlags |= TypeScript.TypeFlags.HasImplementation; }; Type.prototype.isDouble = function () { return TypeScript.hasFlag(this.primitiveTypeClass, Primitive.Double); }; Type.prototype.isString = function () { return TypeScript.hasFlag(this.primitiveTypeClass, Primitive.String); }; Type.prototype.isBoolean = function () { return TypeScript.hasFlag(this.primitiveTypeClass, Primitive.Boolean); }; Type.prototype.isNull = function () { return TypeScript.hasFlag(this.primitiveTypeClass, Primitive.Null); }; Type.prototype.getTypeName = function () { return this.getMemberTypeName("", true, false, null); }; Type.prototype.getScopedTypeName = function (scope) { return this.getMemberTypeName("", true, false, scope); }; Type.prototype.getScopedTypeNameEx = function (scope) { return this.getMemberTypeNameEx("", true, false, scope); }; Type.prototype.callCount = function () { var total = 0; if(this.call) { total += this.call.signatures.length; } if(this.construct) { total += this.construct.signatures.length; } if(this.index) { total += this.index.signatures.length; } return total; }; Type.prototype.getMemberTypeName = function (prefix, topLevel, isElementType, scope) { var memberName = this.getMemberTypeNameEx(prefix, topLevel, isElementType, scope); return memberName.toString(); }; Type.prototype.getMemberTypeNameEx = function (prefix, topLevel, isElementType, scope) { if(this.elementType) { return MemberName.create(this.elementType.getMemberTypeNameEx(prefix, false, true, scope), "", "[]"); } else { if(this.symbol && this.symbol.name && this.symbol.name != "_anonymous" && (((this.call == null) && (this.construct == null) && (this.index == null)) || (TypeScript.hasFlag(this.typeFlags, TypeScript.TypeFlags.BuildingName)) || (this.members && (!this.isClass())))) { var tn = this.symbol.scopeRelativeName(scope); return MemberName.create(tn == "null" ? "any" : tn); } else { if(this.members || this.call || this.construct) { if(TypeScript.hasFlag(this.typeFlags, TypeScript.TypeFlags.BuildingName)) { return MemberName.create("this"); } this.typeFlags |= TypeScript.TypeFlags.BuildingName; var builder = ""; var allMemberNames = new MemberNameArray(); var curlies = isElementType || this.index != null; var memCount = 0; var delim = "; "; if(this.members) { this.members.allMembers.map(function (key, s, unused) { var sym = s; if(!TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.BuiltIn)) { var typeNameMember = sym.getTypeNameEx(scope); if(typeNameMember.isArray() && (typeNameMember).delim == delim) { allMemberNames.addAll((typeNameMember).entries); } else { allMemberNames.add(typeNameMember); } memCount++; curlies = true; } }, null); } var signatureCount = this.callCount(); var j; var len = 0; var shortform = !curlies && signatureCount == 1 && topLevel; if(this.call) { allMemberNames.addAll(this.call.toStrings(prefix, shortform, scope)); } if(this.construct) { allMemberNames.addAll(this.construct.toStrings("new", shortform, scope)); } if(this.index) { allMemberNames.addAll(this.index.toStrings("", shortform, scope)); } if((curlies) || ((signatureCount > 1) && topLevel)) { allMemberNames.prefix = "{ "; allMemberNames.suffix = "}"; allMemberNames.delim = delim; } else { if(allMemberNames.entries.length > 1) { allMemberNames.delim = delim; } } this.typeFlags &= (~TypeScript.TypeFlags.BuildingName); if((signatureCount == 0) && (memCount == 0)) { return MemberName.create("{}"); } else { return allMemberNames; } } else { return MemberName.create("{}"); } } } }; Type.prototype.checkDecl = function (checker) { if(this.isClassInstance() || this.isClass()) { if(this.symbol.declAST) { checker.typeFlow.inScopeTypeCheckDecl(this.symbol.declAST); } } }; Type.prototype.getMemberScope = function (flow) { if(this == flow.anyType) { return null; } else { if(this.isDouble()) { if(flow.numberInterfaceType) { return flow.numberInterfaceType.memberScope; } else { return null; } } else { if(this.isBoolean()) { if(flow.booleanInterfaceType) { return flow.booleanInterfaceType.memberScope; } else { return null; } } else { if(this == flow.stringType) { if(flow.stringInterfaceType) { return flow.stringInterfaceType.memberScope; } else { return null; } } else { if(this.elementType) { if(flow.arrayInterfaceType) { var arrInstType = this.elementType.getArrayBase(flow.arrayInterfaceType, flow.checker); return arrInstType.memberScope; } else { return null; } } else { return this.memberScope; } } } } } }; Type.prototype.isReferenceType = function () { return this.members || this.extendsList || this.construct || this.call || this.index || this.elementType; }; Type.prototype.specializeType = function (pattern, replacement, checker, membersOnly) { if(pattern == this) { return replacement; } var result = this; if(membersOnly) { if(this.isReferenceType()) { result = new Type(); if(this.members) { result.members = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); this.members.publicMembers.map(function (key, s, unused) { var sym = s; var bSym = sym.specializeType(pattern, replacement, checker); result.members.addPublicMember(bSym.name, bSym); }, null); this.members.privateMembers.map(function (key, s, unused) { var sym = s; var bSym = sym.specializeType(pattern, replacement, checker); result.members.addPrivateMember(bSym.name, bSym); }, null); } if(this.ambientMembers) { result.ambientMembers = new TypeScript.ScopedMembers(new TypeScript.DualStringHashTable(new TypeScript.StringHashTable(), new TypeScript.StringHashTable())); this.ambientMembers.publicMembers.map(function (key, s, unused) { var sym = s; var bSym = sym.specializeType(pattern, replacement, checker); result.ambientMembers.addPublicMember(bSym.name, bSym); }, null); this.ambientMembers.privateMembers.map(function (key, s, unused) { var sym = s; var bSym = sym.specializeType(pattern, replacement, checker); result.ambientMembers.addPrivateMember(bSym.name, bSym); }, null); } result.containedScope = checker.scopeOf(result); result.memberScope = result.containedScope; } } else { if(this.elementType) { if(this.elementType == pattern) { result = checker.makeArrayType(replacement); } else { if(this.elementType.elementType == pattern) { result = checker.makeArrayType(checker.makeArrayType(replacement)); } } } else { if(this.call) { result = new Type(); result.call = this.call.specializeType(pattern, replacement, checker); } } } return result; }; Type.prototype.hasBase = function (baseType) { if(baseType == this) { return true; } else { if(this.extendsList) { for(var i = 0, len = this.extendsList.length; i < len; i++) { if(this.extendsList[i].hasBase(baseType)) { return true; } } } } return false; }; Type.prototype.mergeOrdered = function (b, checker, acceptVoid, comparisonInfo) { if((this == checker.anyType) || (b == checker.anyType)) { return checker.anyType; } else { if(this == b) { return this; } else { if((b == checker.nullType) && this != checker.nullType) { return this; } else { if((this == checker.nullType) && (b != checker.nullType)) { return b; } else { if(acceptVoid && (b == checker.voidType) && this != checker.voidType) { return this; } else { if(acceptVoid && (this == checker.voidType) && (b != checker.voidType)) { return b; } else { if((b == checker.undefinedType) && this != checker.undefinedType) { return this; } else { if((this == checker.undefinedType) && (b != checker.undefinedType)) { return b; } else { if(this.elementType && b.elementType) { if(this.elementType == b.elementType) { return this; } else { var mergedET = this.elementType.mergeOrdered(b.elementType, checker, acceptVoid, comparisonInfo); if(mergedET == null) { return checker.makeArrayType(checker.anyType); } else { return checker.makeArrayType(mergedET); } } } else { if(checker.sourceIsSubtypeOfTarget(this, b, comparisonInfo)) { return b; } else { if(checker.sourceIsSubtypeOfTarget(b, this, comparisonInfo)) { return this; } else { return null; } } } } } } } } } } } }; Type.prototype.isModuleType = function () { return false; }; Type.prototype.hasMembers = function () { return this.members != null; }; Type.prototype.getAllEnclosedTypes = function () { return null; }; Type.prototype.getAllAmbientEnclosedTypes = function () { return null; }; Type.prototype.getPublicEnclosedTypes = function () { return null; }; Type.prototype.getpublicAmbientEnclosedTypes = function () { return null; }; Type.prototype.getDocComments = function () { if(this.elementType || !this.symbol) { return []; } if(this.isClassInstance() || this.isClass()) { if(this.symbol.declAST.nodeType == TypeScript.NodeType.FuncDecl) { return (this.symbol.declAST).classDecl.getDocComments(); } else { return this.symbol.getDocComments(); } } if(this.symbol.name && this.symbol.name != "_anonymous" && (((this.call == null) && (this.construct == null) && (this.index == null)) || this.members)) { return this.symbol.getDocComments(); } return []; }; return Type; })(); TypeScript.Type = Type; var ModuleType = (function (_super) { __extends(ModuleType, _super); function ModuleType(enclosedTypes, ambientEnclosedTypes) { _super.call(this); this.enclosedTypes = enclosedTypes; this.ambientEnclosedTypes = ambientEnclosedTypes; this.importedModules = []; } ModuleType.prototype.isModuleType = function () { return true; }; ModuleType.prototype.hasMembers = function () { return this.members != null || this.enclosedTypes != null; }; ModuleType.prototype.getAllEnclosedTypes = function () { return this.enclosedTypes; }; ModuleType.prototype.getAllAmbientEnclosedTypes = function () { return this.ambientEnclosedTypes; }; ModuleType.prototype.getPublicEnclosedTypes = function () { return null; }; ModuleType.prototype.getpublicAmbientEnclosedTypes = function () { return null; }; ModuleType.findDynamicModuleNameInHashTable = function findDynamicModuleNameInHashTable(moduleType, members) { var moduleName = null; members.map(function (key, s, c) { if(moduleName == null && !TypeScript.isQuoted(key)) { var symbol = s; var type = symbol.getType(); if(type == moduleType) { moduleName = { name: key, symbol: symbol }; } } }, null); return moduleName; } ModuleType.prototype.findDynamicModuleName = function (moduleType) { var moduleName = null; moduleName = ModuleType.findDynamicModuleNameInHashTable(moduleType, this.members.allMembers); if(moduleName == null) { moduleName = ModuleType.findDynamicModuleNameInHashTable(moduleType, this.ambientMembers.allMembers); } return moduleName; }; return ModuleType; })(Type); TypeScript.ModuleType = ModuleType; var TypeLink = (function () { function TypeLink() { this.type = null; this.ast = null; } return TypeLink; })(); TypeScript.TypeLink = TypeLink; function getTypeLink(ast, checker, autoVar) { var result = new TypeLink(); result.ast = ast; if((ast == null) && (autoVar)) { result.type = checker.anyType; } else { result.type = null; } return result; } TypeScript.getTypeLink = getTypeLink; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { function stripQuotes(str) { return str.replace("\"", "").replace("'", "").replace("'", "").replace("\"", ""); } TypeScript.stripQuotes = stripQuotes; function isQuoted(str) { return str.indexOf("\"") != -1 || str.indexOf("'") != -1 || str.indexOf("'") != -1 || str.indexOf("\"") != -1; } TypeScript.isQuoted = isQuoted; function quoteStr(str) { return "\"" + str + "\""; } TypeScript.quoteStr = quoteStr; function swapQuotes(str) { if(str.indexOf("\"") != -1) { str = str.replace("\"", "'"); str = str.replace("\"", "'"); } else { str = str.replace("'", "\""); str = str.replace("'", "\""); } return str; } TypeScript.swapQuotes = swapQuotes; function switchToForwardSlashes(path) { return path.replace(/\\/g, "/"); } TypeScript.switchToForwardSlashes = switchToForwardSlashes; function trimModName(modName) { if(modName.length > 6 && modName.substring(modName.length - 6, modName.length) == ".d.str") { return modName.substring(0, modName.length - 6); } if(modName.length > 4 && modName.substring(modName.length - 4, modName.length) == ".str") { return modName.substring(0, modName.length - 4); } if(modName.length > 5 && modName.substring(modName.length - 5, modName.length) == ".d.ts") { return modName.substring(0, modName.length - 5); } if(modName.length > 3 && modName.substring(modName.length - 3, modName.length) == ".ts") { return modName.substring(0, modName.length - 3); } if(modName.length > 3 && modName.substring(modName.length - 3, modName.length) == ".js") { return modName.substring(0, modName.length - 3); } return modName; } TypeScript.trimModName = trimModName; function getDeclareFilePath(fname) { return isSTRFile(fname) ? changePathToDSTR(fname) : isTSFile(fname) ? changePathToDTS(fname) : changePathToDTS(fname); } TypeScript.getDeclareFilePath = getDeclareFilePath; function isFileOfExtension(fname, ext) { var invariantFname = fname.toLocaleUpperCase(); var invariantExt = ext.toLocaleUpperCase(); var extLength = invariantExt.length; return invariantFname.length > extLength && invariantFname.substring(invariantFname.length - extLength, invariantFname.length) == invariantExt; } function isJSFile(fname) { return isFileOfExtension(fname, ".js"); } TypeScript.isJSFile = isJSFile; function isSTRFile(fname) { return isFileOfExtension(fname, ".str"); } TypeScript.isSTRFile = isSTRFile; function isTSFile(fname) { return isFileOfExtension(fname, ".ts"); } TypeScript.isTSFile = isTSFile; function isDSTRFile(fname) { return isFileOfExtension(fname, ".d.str"); } TypeScript.isDSTRFile = isDSTRFile; function isDTSFile(fname) { return isFileOfExtension(fname, ".d.ts"); } TypeScript.isDTSFile = isDTSFile; function getPrettyName(modPath, quote, treatAsFileName) { if (typeof quote === "undefined") { quote = true; } if (typeof treatAsFileName === "undefined") { treatAsFileName = false; } var modName = treatAsFileName ? switchToForwardSlashes(modPath) : trimModName(stripQuotes(modPath)); var components = this.getPathComponents(modName); return components.length ? (quote ? quoteStr(components[components.length - 1]) : components[components.length - 1]) : modPath; } TypeScript.getPrettyName = getPrettyName; function getPathComponents(path) { return path.split("/"); } TypeScript.getPathComponents = getPathComponents; function getRelativePathToFixedPath(fixedModFilePath, absoluteModPath) { absoluteModPath = switchToForwardSlashes(absoluteModPath); var modComponents = this.getPathComponents(absoluteModPath); var fixedModComponents = this.getPathComponents(fixedModFilePath); var joinStartIndex = 0; for(; joinStartIndex < modComponents.length && joinStartIndex < fixedModComponents.length; joinStartIndex++) { if(fixedModComponents[joinStartIndex] != modComponents[joinStartIndex]) { break; } } if(joinStartIndex != 0) { var relativePath = ""; var relativePathComponents = modComponents.slice(joinStartIndex, modComponents.length); for(; joinStartIndex < fixedModComponents.length; joinStartIndex++) { if(fixedModComponents[joinStartIndex] != "") { relativePath = relativePath + "../"; } } return relativePath + relativePathComponents.join("/"); } return absoluteModPath; } TypeScript.getRelativePathToFixedPath = getRelativePathToFixedPath; function quoteBaseName(modPath) { var modName = trimModName(stripQuotes(modPath)); var path = getRootFilePath(modName); if(path == "") { return modPath; } else { var components = modName.split(path); var fileIndex = components.length > 1 ? 1 : 0; return quoteStr(components[fileIndex]); } } TypeScript.quoteBaseName = quoteBaseName; function changePathToSTR(modPath) { return trimModName(stripQuotes(modPath)) + ".str"; } TypeScript.changePathToSTR = changePathToSTR; function changePathToDSTR(modPath) { return trimModName(stripQuotes(modPath)) + ".d.str"; } TypeScript.changePathToDSTR = changePathToDSTR; function changePathToTS(modPath) { return trimModName(stripQuotes(modPath)) + ".ts"; } TypeScript.changePathToTS = changePathToTS; function changePathToDTS(modPath) { return trimModName(stripQuotes(modPath)) + ".d.ts"; } TypeScript.changePathToDTS = changePathToDTS; function isRelative(path) { return path.charAt(0) == "."; } TypeScript.isRelative = isRelative; function isRooted(path) { return path.charAt(0) == "\\" || path.charAt(0) == "/" || (path.indexOf(":\\") != -1) || (path.indexOf(":/") != -1); } TypeScript.isRooted = isRooted; function getRootFilePath(outFname) { if(outFname == "") { return outFname; } else { var isPath = outFname.indexOf("/") != -1; return isPath ? filePath(outFname) : ""; } } TypeScript.getRootFilePath = getRootFilePath; function filePathComponents(fullPath) { fullPath = switchToForwardSlashes(fullPath); var components = getPathComponents(fullPath); return components.slice(0, components.length - 1); } TypeScript.filePathComponents = filePathComponents; function filePath(fullPath) { var path = filePathComponents(fullPath); return path.join("/") + "/"; } TypeScript.filePath = filePath; function normalizeURL(url) { var hostDomainAndPortRegex = /^(https?:\/\/[\-\w\.]+(:\d+)?\/)(.*)$/i; var matches = hostDomainAndPortRegex.exec(url); if(matches) { var hostDomainAndPort = matches[1]; var actualPath = matches[3]; return hostDomainAndPort + normalizePath(actualPath); } return normalizePath(url); } TypeScript.normalizeURL = normalizeURL; TypeScript.pathNormalizeRegExp = /\//g; function normalizePath(path) { path = switchToForwardSlashes(path); var startedWithSep = path.charAt(0) === "/"; var parts = this.getPathComponents(path); for(var i = 0; i < parts.length; i++) { if(parts[i] === "." || parts[i] === "") { parts.splice(i, 1); i--; } if(i > 0 && parts[i] === ".." && parts[i - 1] !== "..") { parts.splice(i - 1, 2); i -= 2; } } return (startedWithSep ? "/" : "") + parts.join("/"); } TypeScript.normalizePath = normalizePath; function normalizeImportPath(path) { return normalizePath(path); } TypeScript.normalizeImportPath = normalizeImportPath; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var SourceUnit = (function () { function SourceUnit(path, content) { this.path = path; this.content = content; this.referencedFiles = null; } SourceUnit.prototype.getText = function (start, end) { return this.content.substring(start, end); }; SourceUnit.prototype.getLength = function () { return this.content.length; }; return SourceUnit; })(); TypeScript.SourceUnit = SourceUnit; var CompilationEnvironment = (function () { function CompilationEnvironment(compilationSettings, ioHost) { this.compilationSettings = compilationSettings; this.ioHost = ioHost; this.residentCode = []; this.code = []; } return CompilationEnvironment; })(); TypeScript.CompilationEnvironment = CompilationEnvironment; var CodeResolver = (function () { function CodeResolver(environment) { this.environment = environment; this.visited = { }; } CodeResolver.prototype.resolveCode = function (referencePath, parentPath, performSearch, resolutionDispatcher) { var resolvedFile = { content: "", path: referencePath }; var ioHost = this.environment.ioHost; var isRelativePath = TypeScript.isRelative(referencePath); var isRootedPath = isRelativePath ? false : TypeScript.isRooted(referencePath); var normalizedPath = isRelativePath ? ioHost.resolvePath(parentPath + "/" + referencePath) : (isRootedPath || !parentPath || performSearch ? referencePath : parentPath + "/" + referencePath); if(!TypeScript.isSTRFile(normalizedPath) && !TypeScript.isTSFile(normalizedPath)) { normalizedPath += ".ts"; } normalizedPath = TypeScript.switchToForwardSlashes(TypeScript.stripQuotes(normalizedPath)); var absoluteModuleID = this.environment.compilationSettings.useCaseSensitiveFileResolution ? normalizedPath : normalizedPath.toLocaleUpperCase(); if(!this.visited[absoluteModuleID]) { if(isRelativePath || isRootedPath || !performSearch) { try { TypeScript.CompilerDiagnostics.debugPrint(" Reading code from " + normalizedPath); try { resolvedFile.content = ioHost.readFile(normalizedPath); } catch (err) { try { if(TypeScript.isSTRFile(normalizedPath)) { normalizedPath = TypeScript.changePathToTS(normalizedPath); } else { if(TypeScript.isTSFile(normalizedPath)) { normalizedPath = TypeScript.changePathToSTR(normalizedPath); } } TypeScript.CompilerDiagnostics.debugPrint(" Reading code from " + normalizedPath); resolvedFile.content = ioHost.readFile(normalizedPath); } catch (err) { normalizedPath = TypeScript.changePathToDSTR(normalizedPath); TypeScript.CompilerDiagnostics.debugPrint(" Reading code from " + normalizedPath); try { resolvedFile.content = ioHost.readFile(normalizedPath); } catch (err) { normalizedPath = TypeScript.changePathToDTS(normalizedPath); TypeScript.CompilerDiagnostics.debugPrint(" Reading code from " + normalizedPath); resolvedFile.content = ioHost.readFile(normalizedPath); } } } TypeScript.CompilerDiagnostics.debugPrint(" Found code at " + normalizedPath); resolvedFile.path = normalizedPath; this.visited[absoluteModuleID] = true; } catch (err) { TypeScript.CompilerDiagnostics.debugPrint(" Did not find code for " + referencePath); } } else { resolvedFile = ioHost.findFile(parentPath, normalizedPath); if(!resolvedFile) { if(TypeScript.isSTRFile(normalizedPath)) { normalizedPath = TypeScript.changePathToTS(normalizedPath); } else { if(TypeScript.isTSFile(normalizedPath)) { normalizedPath = TypeScript.changePathToSTR(normalizedPath); } } resolvedFile = ioHost.findFile(parentPath, normalizedPath); } if(!resolvedFile) { normalizedPath = TypeScript.changePathToDTS(normalizedPath); resolvedFile = ioHost.findFile(parentPath, normalizedPath); if(!resolvedFile) { normalizedPath = TypeScript.changePathToDSTR(normalizedPath); resolvedFile = ioHost.findFile(parentPath, normalizedPath); } } if(resolvedFile) { resolvedFile.path = TypeScript.switchToForwardSlashes(TypeScript.stripQuotes(resolvedFile.path)); TypeScript.CompilerDiagnostics.debugPrint(referencePath + " resolved to: " + resolvedFile.path); resolvedFile.content = resolvedFile.content; this.visited[absoluteModuleID] = true; } else { TypeScript.CompilerDiagnostics.debugPrint("Could not find " + referencePath); } } if(resolvedFile && resolvedFile.content) { var rootDir = ioHost.dirName(resolvedFile.path); var sourceUnit = new SourceUnit(resolvedFile.path, resolvedFile.content); var preProcessedFileInfo = TypeScript.preProcessFile(sourceUnit, this.environment.compilationSettings); sourceUnit.referencedFiles = preProcessedFileInfo.referencedFiles; for(var i = 0; i < preProcessedFileInfo.referencedFiles.length; i++) { var referencedFile = preProcessedFileInfo.referencedFiles[i]; var normalizedPath = TypeScript.isRooted(referencedFile.path) ? referencedFile.path : rootDir + "/" + referencedFile.path; normalizedPath = ioHost.resolvePath(normalizedPath); if(referencePath == normalizedPath) { resolutionDispatcher.postResolutionError(normalizedPath, "File contains reference to itself", null); continue; } this.resolveCode(referencedFile.path, rootDir, false, resolutionDispatcher); } for(var i = 0; i < preProcessedFileInfo.importedFiles.length; i++) { this.resolveCode(preProcessedFileInfo.importedFiles[i].path, rootDir, true, resolutionDispatcher); } resolutionDispatcher.postResolution(sourceUnit.path, sourceUnit); } } }; return CodeResolver; })(); TypeScript.CodeResolver = CodeResolver; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var StyleSettings = (function () { function StyleSettings() { this.bitwise = false; this.blockInCompoundStmt = false; this.eqeqeq = false; this.forin = false; this.emptyBlocks = true; this.newMustBeUsed = false; this.requireSemi = false; this.assignmentInCond = false; this.eqnull = false; this.evalOK = true; this.innerScopeDeclEscape = true; this.funcInLoop = true; this.reDeclareLocal = true; this.literalSubscript = true; this.implicitAny = false; } StyleSettings.prototype.setOption = function (opt, val) { var optExists = this[opt]; if(optExists !== undefined) { this[opt] = val; return true; } else { return false; } }; StyleSettings.prototype.parseOptions = function (str) { var opts = str.split(";"); for(var i = 0, len = opts.length; i < len; i++) { var opt = opts[i]; var val = true; var colonIndex = opt.lastIndexOf(":"); if(colonIndex >= 0) { var valStr = opt.substring(colonIndex + 1); opt = opt.substring(0, colonIndex); if(valStr == "off") { val = false; } } if(!this.setOption(opt, val)) { return false; } } return true; }; return StyleSettings; })(); TypeScript.StyleSettings = StyleSettings; var CompilationSettings = (function () { function CompilationSettings() { this.styleSettings = new StyleSettings(); this.propagateConstants = false; this.minWhitespace = false; this.parseOnly = false; this.errorRecovery = false; this.emitComments = false; this.watch = false; this.exec = false; this.resolve = true; this.controlFlow = false; this.printControlFlow = false; this.controlFlowUseDef = false; this.errorOnWith = true; this.preprocess = true; this.canCallDefinitionSignature = false; this.inferPropertiesFromThisAssignment = false; this.useDefaultLib = true; this.codeGenTarget = TypeScript.CodeGenTarget.ES3; this.moduleGenTarget = TypeScript.ModuleGenTarget.Synchronous; this.outputOption = ""; this.mapSourceFiles = false; this.generateDeclarationFiles = false; this.useCaseSensitiveFileResolution = false; } CompilationSettings.prototype.setStyleOptions = function (str) { this.styleSettings.parseOptions(str); }; return CompilationSettings; })(); TypeScript.CompilationSettings = CompilationSettings; function getFileReferenceFromReferencePath(comment) { var referencesRegEx = /^(\/\/\/\s*/igm; var match = referencesRegEx.exec(comment); if(match) { var path = TypeScript.normalizePath(match[3]); var adjustedPath = TypeScript.normalizePath(path); var isResident = match.length >= 7 && match[6] == "true"; if(isResident) { TypeScript.CompilerDiagnostics.debugPrint(path + " is resident"); } return { minChar: 0, limChar: 0, path: TypeScript.switchToForwardSlashes(adjustedPath), isResident: isResident }; } else { return null; } } function getAdditionalDependencyPath(comment) { var amdDependencyRegEx = /^(\/\/\/\s*/igm; var match = amdDependencyRegEx.exec(comment); if(match) { var path = match[3]; return path; } else { return null; } } TypeScript.getAdditionalDependencyPath = getAdditionalDependencyPath; function getImplicitImport(comment) { var implicitImportRegEx = /^(\/\/\/\s*/igm; var match = implicitImportRegEx.exec(comment); if(match) { return true; } return false; } TypeScript.getImplicitImport = getImplicitImport; function getStyleSettings(comment, styleSettings) { var styleRegEx = /^(\/\/\/\s*/igm; var settings = styleRegEx.exec(comment); if(settings) { var settingsRegEx = /^([a-zA-Z]+=['"]on['|"])/igm; settings = settingsRegEx.exec(settings[2]); if(settings) { for(var i = 0; i < settings.length; i++) { var setting = (settings[i]).split("="); var on = "\"on\""; switch(setting[0]) { case "blockInCompoundStmt": { styleSettings.blockInCompoundStmt = setting[1] == on; break; } case "eqeqeq": { styleSettings.eqeqeq = setting[1] == on; break; } case "forin": { styleSettings.forin = setting[1] == on; break; } case "emptyBlocks": { styleSettings.emptyBlocks = setting[1] == on; break; } case "newMustBeUsed": { styleSettings.newMustBeUsed = setting[1] == on; break; } case "requireSemi": { styleSettings.requireSemi = setting[1] == on; break; } case "assignmentInCond": { styleSettings.assignmentInCond = setting[1] == on; break; } case "eqnull": { styleSettings.eqnull = setting[1] == on; break; } case "evalOK": { styleSettings.evalOK = setting[1] == on; break; } case "innerScopeDeclEscape": { styleSettings.innerScopeDeclEscape = setting[1] == on; break; } case "funcInLoop": { styleSettings.funcInLoop = setting[1] == on; break; } case "reDeclareLocal": { styleSettings.reDeclareLocal = setting[1] == on; break; } case "literalSubscript": { styleSettings.literalSubscript = setting[1] == on; break; } case "implicitAny": { styleSettings.implicitAny = setting[1] == on; break; } } } } } } TypeScript.getStyleSettings = getStyleSettings; function getReferencedFiles(sourceText) { var preProcessInfo = preProcessFile(sourceText, null, false); return preProcessInfo.referencedFiles; } TypeScript.getReferencedFiles = getReferencedFiles; function preProcessFile(sourceText, options, readImportFiles) { if (typeof options === "undefined") { options = new CompilationSettings(); } if (typeof readImportFiles === "undefined") { readImportFiles = true; } var scanner = new TypeScript.Scanner(); scanner.resetComments(); scanner.setSourceText(sourceText, TypeScript.LexMode.File); var tok = scanner.scan(); var comments = []; var comment = null; var leftCurlies = []; var settings = options; var referencedFiles = []; var importedFiles = []; var isLibFile = false; while(tok.tokenId != TypeScript.TokenID.EndOfFile) { if(readImportFiles && tok.tokenId == TypeScript.TokenID.Import) { tok = scanner.scan(); if(tok.tokenId == TypeScript.TokenID.Identifier || TypeScript.convertTokToID(tok, false)) { tok = scanner.scan(); if(tok.tokenId == TypeScript.TokenID.Equals) { tok = scanner.scan(); if(tok.tokenId == TypeScript.TokenID.Module) { tok = scanner.scan(); if(tok.tokenId == TypeScript.TokenID.OpenParen) { tok = scanner.scan(); if(tok.tokenId == TypeScript.TokenID.StringLiteral) { var ref = { minChar: scanner.startPos, limChar: scanner.pos, path: TypeScript.stripQuotes(TypeScript.switchToForwardSlashes(tok.getText())), isResident: false }; importedFiles.push(ref); } } } } } } if(tok.tokenId == TypeScript.TokenID.OpenBrace) { leftCurlies.push(tok); } if(tok.tokenId == TypeScript.TokenID.CloseBrace) { leftCurlies.pop(); } tok = scanner.scan(); } comments = scanner.getComments(); for(var iComment = 0; iComment < comments.length; iComment++) { comment = comments[iComment]; if(!comment.isBlock) { var referencedCode = getFileReferenceFromReferencePath(comment.getText()); if(referencedCode) { referencedCode.minChar = comment.startPos; referencedCode.limChar = referencedCode.minChar + comment.value.length; referencedFiles.push(referencedCode); } if(settings) { getStyleSettings(comment.getText(), settings.styleSettings); var isNoLibRegex = /^(\/\/\/\s*/igm; var isNoLibMatch = isNoLibRegex.exec(comment.getText()); if(isNoLibMatch) { isLibFile = (isNoLibMatch[3] == "true"); } } } } return { settings: settings, referencedFiles: referencedFiles, importedFiles: importedFiles, isLibFile: isLibFile }; } TypeScript.preProcessFile = preProcessFile; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var IncrementalParser = (function () { function IncrementalParser(logger) { this.logger = logger; this.astLogger = new TypeScript.AstLogger(this.logger); } IncrementalParser.prototype.getEnclosingScopeContextIfSingleScopeEdit = function (previousScript, scriptId, newSourceText, editRange) { this.logger.log("checkEditsInsideSingleScope(\"" + scriptId + "\")"); if(editRange === null) { throw new Error("editRange should be valid"); } if(editRange.isUnknown()) { this.logger.log(" Bailing out because edit range is unknown"); return null; } var scope1 = TypeScript.findEnclosingScopeAt(this.logger, previousScript, newSourceText, editRange.minChar, false); var scope2 = TypeScript.findEnclosingScopeAt(this.logger, previousScript, newSourceText, editRange.limChar, false); if(scope1 == null || scope2 == null) { this.logger.log(" Bailing out because containing scopes cannot be determined"); return null; } if(scope1.scopeStartAST !== scope2.scopeStartAST) { this.logger.log(" Bailing out because edit overlaps 2 disctint scopes"); return null; } var newScopeLength = scope1.scopeStartAST.limChar - scope1.scopeStartAST.minChar + editRange.delta; if(newScopeLength <= 0) { this.logger.log(" Bailing out because scope has been entirely removed from new source text"); return null; } return scope1; }; IncrementalParser.prototype.attemptIncrementalUpdateUnit = function (previousScript, scriptId, newSourceText, editRange) { this.logger.log("attemptIncrementalUpdateUnit(\"" + scriptId + "\")"); if(editRange === null) { throw new Error("editRange should be valid"); } var scope1 = this.getEnclosingScopeContextIfSingleScopeEdit(previousScript, scriptId, newSourceText, editRange); if(scope1 === null) { return null; } var newScopeLength = scope1.scopeStartAST.limChar - scope1.scopeStartAST.minChar + editRange.delta; if(newScopeLength >= newSourceText.getLength() / 2) { this.logger.log(" Bailing out because range of scope to reparse (" + newScopeLength + " characters) is greater than half the size of the source text"); return null; } var parseErrors = []; var errorCapture = function (minChar, charLen, message, unitIndex) { parseErrors.push(new TypeScript.ErrorEntry(unitIndex, minChar, minChar + charLen, message)); }; var quickParseResult = TypeScript.quickParse(this.logger, scope1.scopeStartAST, newSourceText, scope1.scopeStartAST.minChar, scope1.scopeStartAST.minChar + newScopeLength, errorCapture); if(quickParseResult.endLexState != TypeScript.LexState.Start) { this.logger.log(" Bailing out because scope contains unterminated comment"); return null; } var scriptFragment = quickParseResult.Script; if(scriptFragment.vars.members.length !== 0) { this.logger.log(" Bailing out because new source text defines variables"); return null; } if(scriptFragment.bod.members.length !== 1) { this.logger.log(" Bailing out because new source text defines more than one scope (or none)"); return null; } var oldScope = scope1.scopeStartAST; var newScope = scriptFragment.bod.members[0]; if(oldScope.nodeType != newScope.nodeType) { this.logger.log(" Bailing out because new source text does not define the same scope type as the existing scope"); return null; } if(!(oldScope).leftCurlyCount || !(oldScope).rightCurlyCount) { this.logger.log(" Bailing out because sopce doesn't have left/right curly count"); return null; } if((oldScope).leftCurlyCount !== (newScope).leftCurlyCount) { this.logger.log(" Bailing out because new source text contains more (or fewer) left curly braces"); return null; } if((oldScope).rightCurlyCount !== (newScope).rightCurlyCount) { this.logger.log(" Bailing out because new source text contains more (or fewer) right curly braces"); return null; } if(newScope.minChar !== 0) { this.logger.log(" Bailing out because new function declaration does not start at position 0"); return null; } if(newScope.limChar !== newScopeLength) { this.logger.log(" Bailing out because new function declaration does not end at the new end position"); return null; } return TypeScript.UpdateUnitResult.singleScopeEdits(previousScript, scriptFragment, oldScope, newScope, editRange, parseErrors); }; IncrementalParser.prototype.mergeTrees = function (updateResult) { var _this = this; TypeScript.timeFunction(this.logger, "mergeTrees()", function () { var editRange = new TypeScript.ScriptEditRange(updateResult.scope1.minChar, updateResult.scope1.limChar, updateResult.editRange.delta); _this.applyDeltaPosition(updateResult.script1, editRange.limChar, editRange.delta); _this.applyDeltaPosition(updateResult.script2, 0, editRange.minChar); _this.mergeLocationInfo(updateResult.script1, updateResult.script2, editRange); _this.replaceAST(updateResult.script1, updateResult.scope1, updateResult.scope2); }); }; IncrementalParser.prototype.replaceAST = function (script, oldAst, newAst) { var _this = this; var pre = function (cur, parent, walker) { if(cur === oldAst) { newAst.preComments = cur.preComments; newAst.postComments = cur.postComments; _this.logger.log("replaced old AST node with new one in script AST"); walker.options.stopWalk(); return newAst; } if(TypeScript.isValidAstNode(cur)) { if(cur.limChar < oldAst.minChar || cur.minChar > oldAst.limChar) { walker.options.goChildren = false; } } return cur; }; TypeScript.getAstWalkerFactory().walk(script, pre); }; IncrementalParser.prototype.mergeLocationInfo = function (script, partial, editRange) { var lineMap1 = script.locationInfo.lineMap; var lineMap2 = partial.locationInfo.lineMap; if(this.logger.information()) { this.logger.log("lineMap1 (before):"); this.astLogger.logLinemap(lineMap1); this.logger.log("lineMap2 (quick parse):"); this.astLogger.logLinemap(lineMap2); this.logger.log("EditRange=" + editRange); } var i1 = 2; var i2 = 2; var len1 = lineMap1.length; var len2 = lineMap2.length; while(i1 < len1) { if(lineMap1[i1] <= editRange.minChar) { i1++; } else { if(lineMap1[i1] >= editRange.limChar) { lineMap1[i1] += editRange.delta; i1++; } else { if(i2 < len2) { lineMap1.splice(i1, 0, lineMap2[i2] + editRange.minChar); i1++; len1++; i2++; } else { lineMap1.splice(i1, 1); len1--; } } } } if(i2 < len2) { if(lineMap1[len1 - 1] >= (lineMap2[i2] + editRange.minChar)) { i1 = 2; while(i1 < len1 && i2 < len2) { if(lineMap1[i1] < (lineMap2[i2] + editRange.minChar)) { i1++; } else { lineMap1.splice(i1, 0, lineMap2[i2] + editRange.minChar); i1++; len1++; i2++; } } } for(; i2 < len2; i2++) { lineMap1.push(lineMap2[i2] + editRange.minChar); } } if(this.logger.information()) { this.logger.log("lineMap1 (after merge):"); this.astLogger.logLinemap(lineMap1); } }; IncrementalParser.prototype.applyDeltaPosition = function (ast, start, delta) { var applyDelta = function (ast) { if(ast.minChar !== -1 && ast.minChar >= start) { ast.minChar += delta; } if(ast.limChar !== -1 && ast.limChar >= start) { ast.limChar += delta; } }; var applyDeltaToComments = function (comments) { if(comments && comments.length > 0) { for(var i = 0; i < comments.length; i++) { applyDelta(comments[i]); } } }; var pre = function (cur, parent, walker) { if(cur.limChar !== -1 && cur.limChar < start) { walker.options.goChildren = false; } applyDelta(cur); applyDeltaToComments(cur.preComments); applyDeltaToComments(cur.postComments); return cur; }; TypeScript.getAstWalkerFactory().walk(ast, pre); }; return IncrementalParser; })(); TypeScript.IncrementalParser = IncrementalParser; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { var DeclFileWriter = (function () { function DeclFileWriter(declFile) { this.declFile = declFile; this.onNewLine = true; } DeclFileWriter.prototype.Write = function (s) { this.declFile.Write(s); this.onNewLine = false; }; DeclFileWriter.prototype.WriteLine = function (s) { this.declFile.WriteLine(s); this.onNewLine = true; }; DeclFileWriter.prototype.Close = function () { this.declFile.Close(); }; return DeclFileWriter; })(); TypeScript.DeclFileWriter = DeclFileWriter; var DeclarationEmitter = (function () { function DeclarationEmitter(checker, emitOptions, errorReporter) { this.checker = checker; this.emitOptions = emitOptions; this.errorReporter = errorReporter; this.declFile = null; this.indenter = new TypeScript.Indenter(); this.declarationContainerStack = []; this.isDottedModuleName = []; this.ignoreCallbackAst = null; this.singleDeclFile = null; this.varListCount = 0; } DeclarationEmitter.prototype.getAstDeclarationContainer = function () { return this.declarationContainerStack[this.declarationContainerStack.length - 1]; }; DeclarationEmitter.prototype.emitDottedModuleName = function () { return (this.isDottedModuleName.length == 0) ? false : this.isDottedModuleName[this.isDottedModuleName.length - 1]; }; DeclarationEmitter.prototype.setDeclarationFile = function (file) { this.declFile = new DeclFileWriter(file); }; DeclarationEmitter.prototype.Close = function () { try { this.declFile.Close(); } catch (ex) { this.errorReporter.emitterError(null, ex.message); } }; DeclarationEmitter.prototype.emitDeclarations = function (script) { TypeScript.AstWalkerWithDetailCallback.walk(script, this); }; DeclarationEmitter.prototype.getIndentString = function (declIndent) { if (typeof declIndent === "undefined") { declIndent = false; } if(this.emitOptions.minWhitespace) { return ""; } else { return this.indenter.getIndent(); } }; DeclarationEmitter.prototype.emitIndent = function () { this.declFile.Write(this.getIndentString()); }; DeclarationEmitter.prototype.canEmitSignature = function (declFlags, canEmitGlobalAmbientDecl, useDeclarationContainerTop) { if (typeof canEmitGlobalAmbientDecl === "undefined") { canEmitGlobalAmbientDecl = true; } if (typeof useDeclarationContainerTop === "undefined") { useDeclarationContainerTop = true; } var container; if(useDeclarationContainerTop) { container = this.getAstDeclarationContainer(); } else { container = this.declarationContainerStack[this.declarationContainerStack.length - 2]; } if(container.nodeType == TypeScript.NodeType.ModuleDeclaration && !TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.Exported)) { return false; } if(!canEmitGlobalAmbientDecl && container.nodeType == TypeScript.NodeType.Script && TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.Ambient)) { return false; } return true; }; DeclarationEmitter.prototype.canEmitPrePostAstSignature = function (declFlags, astWithPrePostCallback, preCallback) { if(this.ignoreCallbackAst) { TypeScript.CompilerDiagnostics.assert(this.ignoreCallbackAst != astWithPrePostCallback, "Ignore Callback AST mismatch"); this.ignoreCallbackAst = null; return false; } else { if(preCallback && !this.canEmitSignature(declFlags, true, preCallback)) { this.ignoreCallbackAst = astWithPrePostCallback; return false; } } return true; }; DeclarationEmitter.prototype.getDeclFlagsString = function (declFlags, typeString) { var result = this.getIndentString(); var accessorString = ""; if(TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.GetAccessor)) { accessorString = "get "; } else { if(TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.SetAccessor)) { accessorString = "set "; } } var container = this.getAstDeclarationContainer(); if(container.nodeType == TypeScript.NodeType.ModuleDeclaration && TypeScript.hasFlag((container).modFlags, TypeScript.ModuleFlags.IsWholeFile) && TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.Exported)) { result += "export "; } if(TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.LocalStatic) || TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.Static)) { result += "static " + accessorString; } else { if(TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.Private)) { result += "private " + accessorString; } else { if(TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.Public)) { result += "public " + accessorString; } else { if(accessorString == "") { result += typeString + " "; } else { result += accessorString; } } } } return result; }; DeclarationEmitter.prototype.emitDeclFlags = function (declFlags, typeString) { this.declFile.Write(this.getDeclFlagsString(declFlags, typeString)); }; DeclarationEmitter.prototype.canEmitTypeAnnotationSignature = function (declFlag) { if (typeof declFlag === "undefined") { declFlag = TypeScript.DeclFlags.None; } return !TypeScript.hasFlag(declFlag, TypeScript.DeclFlags.Private); }; DeclarationEmitter.prototype.pushDeclarationContainer = function (ast) { this.declarationContainerStack.push(ast); }; DeclarationEmitter.prototype.popDeclarationContainer = function (ast) { TypeScript.CompilerDiagnostics.assert(ast != this.getAstDeclarationContainer(), 'Declaration container mismatch'); this.declarationContainerStack.pop(); }; DeclarationEmitter.prototype.emitTypeNamesMember = function (memberName, emitIndent) { if (typeof emitIndent === "undefined") { emitIndent = false; } if(memberName.prefix == "{ ") { if(emitIndent) { this.emitIndent(); } this.declFile.WriteLine("{"); this.indenter.increaseIndent(); emitIndent = true; } else { if(memberName.prefix != "") { if(emitIndent) { this.emitIndent(); } this.declFile.Write(memberName.prefix); emitIndent = false; } } if(memberName.isString()) { if(emitIndent) { this.emitIndent(); } this.declFile.Write((memberName).text); } else { var ar = memberName; for(var index = 0; index < ar.entries.length; index++) { this.emitTypeNamesMember(ar.entries[index], emitIndent); if(ar.delim == "; ") { this.declFile.WriteLine(";"); } } } if(memberName.suffix == "}") { this.indenter.decreaseIndent(); this.emitIndent(); this.declFile.Write(memberName.suffix); } else { this.declFile.Write(memberName.suffix); } }; DeclarationEmitter.prototype.emitTypeSignature = function (type) { var containingScope = null; var declarationContainerAst = this.getAstDeclarationContainer(); switch(declarationContainerAst.nodeType) { case TypeScript.NodeType.ModuleDeclaration: case TypeScript.NodeType.InterfaceDeclaration: case TypeScript.NodeType.FuncDecl: { if(declarationContainerAst.type) { containingScope = declarationContainerAst.type.containedScope; } break; } case TypeScript.NodeType.Script: { var script = declarationContainerAst; if(script.bod) { containingScope = script.bod.enclosingScope; } break; } case TypeScript.NodeType.ClassDeclaration: { if(declarationContainerAst.type) { containingScope = declarationContainerAst.type.instanceType.containedScope; } break; } default: { TypeScript.CompilerDiagnostics.debugPrint("Unknown containing scope"); } } var typeNameMembers = type.getScopedTypeNameEx(containingScope); this.emitTypeNamesMember(typeNameMembers); }; DeclarationEmitter.prototype.emitComment = function (comment) { var text = comment.getText(); if(this.declFile.onNewLine) { this.emitIndent(); } else { if(!comment.isBlockComment) { this.declFile.WriteLine(""); this.emitIndent(); } } this.declFile.Write(text[0]); for(var i = 1; i < text.length; i++) { this.declFile.WriteLine(""); this.emitIndent(); this.declFile.Write(text[i]); } if(comment.endsLine || !comment.isBlockComment) { this.declFile.WriteLine(""); } else { this.declFile.Write(" "); } }; DeclarationEmitter.prototype.emitDeclarationComments = function (astOrSymbol, endLine) { if (typeof endLine === "undefined") { endLine = true; } if(!this.emitOptions.emitComments) { return; } var declComments = astOrSymbol.getDocComments(); if(declComments.length > 0) { for(var i = 0; i < declComments.length; i++) { this.emitComment(declComments[i]); } if(endLine) { if(!this.declFile.onNewLine) { this.declFile.WriteLine(""); } } else { if(this.declFile.onNewLine) { this.emitIndent(); } } } }; DeclarationEmitter.prototype.VarDeclCallback = function (pre, varDecl) { if(pre && this.canEmitSignature(TypeScript.ToDeclFlags(varDecl.varFlags), false)) { var interfaceMember = (this.getAstDeclarationContainer().nodeType == TypeScript.NodeType.InterfaceDeclaration); this.emitDeclarationComments(varDecl); if(!interfaceMember) { if(this.varListCount >= 0) { this.emitDeclFlags(TypeScript.ToDeclFlags(varDecl.varFlags), "var"); this.varListCount = -this.varListCount; } this.declFile.Write(varDecl.id.text); } else { this.emitIndent(); this.declFile.Write(varDecl.id.text); if(TypeScript.hasFlag(varDecl.id.flags, TypeScript.ASTFlags.OptionalName)) { this.declFile.Write("?"); } } var type = null; if(varDecl.typeExpr && varDecl.typeExpr.type) { type = varDecl.typeExpr.type; } else { if(varDecl.sym) { type = (varDecl.sym).getType(); if(type == this.checker.anyType) { type = null; } } } if(type && this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(varDecl.varFlags))) { this.declFile.Write(": "); this.emitTypeSignature(type); } if(this.varListCount > 0) { this.varListCount--; } else { if(this.varListCount < 0) { this.varListCount++; } } if(this.varListCount < 0) { this.declFile.Write(", "); } else { this.declFile.WriteLine(";"); } } return false; }; DeclarationEmitter.prototype.BlockCallback = function (pre, block) { if(!block.isStatementBlock) { if(pre) { this.varListCount = block.statements.members.length; } else { this.varListCount = 0; } return true; } return false; }; DeclarationEmitter.prototype.emitArgDecl = function (argDecl, funcDecl) { this.emitDeclarationComments(argDecl, false); this.declFile.Write(argDecl.id.text); if(argDecl.isOptionalArg()) { this.declFile.Write("?"); } if((argDecl.typeExpr || argDecl.type != this.checker.anyType) && this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(funcDecl.fncFlags))) { this.declFile.Write(": "); this.emitTypeSignature(argDecl.type); } }; DeclarationEmitter.prototype.FuncDeclCallback = function (pre, funcDecl) { if(!pre) { return false; } if(funcDecl.isAccessor()) { return this.emitPropertyAccessorSignature(funcDecl); } var isInterfaceMember = (this.getAstDeclarationContainer().nodeType == TypeScript.NodeType.InterfaceDeclaration); if(funcDecl.bod) { if(funcDecl.isConstructor) { if(funcDecl.type.construct && funcDecl.type.construct.signatures.length > 1) { return false; } } else { if(funcDecl.type.call && funcDecl.type.call.signatures.length > 1) { return false; } } } else { if(!isInterfaceMember && TypeScript.hasFlag(funcDecl.fncFlags, TypeScript.FncFlags.Private) && funcDecl.type.call && funcDecl.type.call.signatures.length > 1) { var signatures = funcDecl.type.call.signatures; var firstSignature = signatures[0].declAST; if(firstSignature.bod) { firstSignature = signatures[1].declAST; } if(firstSignature != funcDecl) { return false; } } } if(!this.canEmitSignature(TypeScript.ToDeclFlags(funcDecl.fncFlags), false)) { return false; } this.emitDeclarationComments(funcDecl); if(funcDecl.isConstructor) { this.emitIndent(); this.declFile.Write("constructor"); } else { var id = funcDecl.getNameText(); if(!isInterfaceMember) { this.emitDeclFlags(TypeScript.ToDeclFlags(funcDecl.fncFlags), "function"); this.declFile.Write(id); } else { this.emitIndent(); if(funcDecl.isConstructMember()) { this.declFile.Write("new"); } else { if(!funcDecl.isCallMember() && !funcDecl.isIndexerMember()) { this.declFile.Write(id); if(TypeScript.hasFlag(funcDecl.name.flags, TypeScript.ASTFlags.OptionalName)) { this.declFile.Write("? "); } } } } } if(!funcDecl.isIndexerMember()) { this.declFile.Write("("); } else { this.declFile.Write("["); } this.indenter.increaseIndent(); if(funcDecl.arguments) { var argsLen = funcDecl.arguments.members.length; if(funcDecl.variableArgList) { argsLen--; } for(var i = 0; i < argsLen; i++) { var argDecl = funcDecl.arguments.members[i]; this.emitArgDecl(argDecl, funcDecl); if(i < (argsLen - 1)) { this.declFile.Write(", "); } } } if(funcDecl.variableArgList) { var lastArg = funcDecl.arguments.members[funcDecl.arguments.members.length - 1]; if(funcDecl.arguments.members.length > 1) { this.declFile.Write(", ..."); } else { this.declFile.Write("..."); } this.emitArgDecl(lastArg, funcDecl); } this.indenter.decreaseIndent(); if(!funcDecl.isIndexerMember()) { this.declFile.Write(")"); } else { this.declFile.Write("]"); } if(!funcDecl.isConstructor && (funcDecl.returnTypeAnnotation || funcDecl.signature.returnType.type != this.checker.anyType) && this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(funcDecl.fncFlags))) { this.declFile.Write(": "); this.emitTypeSignature(funcDecl.signature.returnType.type); } this.declFile.WriteLine(";"); return false; }; DeclarationEmitter.prototype.emitBaseList = function (bases, qual) { if(bases && (bases.members.length > 0)) { this.declFile.Write(" " + qual + " "); var basesLen = bases.members.length; for(var i = 0; i < basesLen; i++) { var baseExpr = bases.members[i]; var baseSymbol = baseExpr.type.symbol; var baseType = baseExpr.type; if(i > 0) { this.declFile.Write(", "); } this.emitTypeSignature(baseType); } } }; DeclarationEmitter.prototype.emitPropertyAccessorSignature = function (funcDecl) { var accessorSymbol = funcDecl.accessorSymbol; if(accessorSymbol.getter && accessorSymbol.getter.declAST != funcDecl) { return false; } this.emitDeclarationComments(accessorSymbol); this.emitDeclFlags(TypeScript.ToDeclFlags(accessorSymbol.flags), "var"); this.declFile.Write(funcDecl.name.text); var propertyType = accessorSymbol.getType(); if(this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(accessorSymbol.flags))) { this.declFile.Write(" : "); this.emitTypeSignature(propertyType); } this.declFile.WriteLine(";"); return false; }; DeclarationEmitter.prototype.emitClassMembersFromConstructorDefinition = function (funcDecl) { if(funcDecl.arguments) { var argsLen = funcDecl.arguments.members.length; if(funcDecl.variableArgList) { argsLen--; } for(var i = 0; i < argsLen; i++) { var argDecl = funcDecl.arguments.members[i]; if(TypeScript.hasFlag(argDecl.varFlags, TypeScript.VarFlags.Property)) { this.emitDeclarationComments(argDecl); this.emitDeclFlags(TypeScript.ToDeclFlags(argDecl.varFlags), "var"); this.declFile.Write(argDecl.id.text); if(argDecl.typeExpr && this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(argDecl.varFlags))) { this.declFile.Write(": "); this.emitTypeSignature(argDecl.type); } this.declFile.WriteLine(";"); } } } }; DeclarationEmitter.prototype.ClassDeclarationCallback = function (pre, classDecl) { if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(classDecl.varFlags), classDecl, pre)) { return false; } if(pre) { var className = classDecl.name.text; this.emitDeclarationComments(classDecl); this.emitDeclFlags(TypeScript.ToDeclFlags(classDecl.varFlags), "class"); this.declFile.Write(className); this.emitBaseList(classDecl.extendsList, "extends"); this.emitBaseList(classDecl.implementsList, "implements"); this.declFile.WriteLine(" {"); this.pushDeclarationContainer(classDecl); this.indenter.increaseIndent(); if(classDecl.constructorDecl) { this.emitClassMembersFromConstructorDefinition(classDecl.constructorDecl); } } else { this.indenter.decreaseIndent(); this.popDeclarationContainer(classDecl); this.emitIndent(); this.declFile.WriteLine("}"); } return true; }; DeclarationEmitter.prototype.InterfaceDeclarationCallback = function (pre, interfaceDecl) { if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(interfaceDecl.varFlags), interfaceDecl, pre)) { return false; } if(pre) { var interfaceName = interfaceDecl.name.text; this.emitDeclarationComments(interfaceDecl); this.emitDeclFlags(TypeScript.ToDeclFlags(interfaceDecl.varFlags), "interface"); this.declFile.Write(interfaceName); this.emitBaseList(interfaceDecl.extendsList, "extends"); this.declFile.WriteLine(" {"); this.indenter.increaseIndent(); this.pushDeclarationContainer(interfaceDecl); } else { this.indenter.decreaseIndent(); this.popDeclarationContainer(interfaceDecl); this.emitIndent(); this.declFile.WriteLine("}"); } return true; }; DeclarationEmitter.prototype.ImportDeclarationCallback = function (pre, importDecl) { if(pre) { if((this.declarationContainerStack[0]).isExternallyVisibleSymbol(importDecl.id.sym)) { this.emitDeclarationComments(importDecl); this.emitIndent(); this.declFile.Write("import "); this.declFile.Write(importDecl.id.text + " = "); if(importDecl.isDynamicImport) { this.declFile.WriteLine("module (" + importDecl.getAliasName() + ");"); } else { this.declFile.WriteLine(importDecl.getAliasName() + ";"); } } } return false; }; DeclarationEmitter.prototype.emitEnumSignature = function (moduleDecl) { if(!this.canEmitSignature(TypeScript.ToDeclFlags(moduleDecl.modFlags))) { return false; } this.emitDeclarationComments(moduleDecl); this.emitDeclFlags(TypeScript.ToDeclFlags(moduleDecl.modFlags), "enum"); this.declFile.WriteLine(moduleDecl.name.text + " {"); this.indenter.increaseIndent(); var membersLen = moduleDecl.members.members.length; for(var j = 1; j < membersLen; j++) { var memberDecl = moduleDecl.members.members[j]; if(memberDecl.nodeType == TypeScript.NodeType.VarDecl) { this.emitDeclarationComments(memberDecl); this.emitIndent(); this.declFile.WriteLine((memberDecl).id.text + ","); } else { TypeScript.CompilerDiagnostics.assert(memberDecl.nodeType != TypeScript.NodeType.Asg, "We want to catch this"); } } this.indenter.decreaseIndent(); this.emitIndent(); this.declFile.WriteLine("}"); return false; }; DeclarationEmitter.prototype.ModuleDeclarationCallback = function (pre, moduleDecl) { if(TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsWholeFile)) { if(TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsDynamic)) { if(pre) { if(!this.emitOptions.outputMany) { this.singleDeclFile = this.declFile; TypeScript.CompilerDiagnostics.assert(this.indenter.indentAmt == 0, "Indent has to be 0 when outputing new file"); var declareFileName = this.emitOptions.mapOutputFileName(TypeScript.stripQuotes(moduleDecl.name.sym.name), TypeScript.TypeScriptCompiler.mapToDTSFileName); var useUTF8InOutputfile = moduleDecl.containsUnicodeChar || (this.emitOptions.emitComments && moduleDecl.containsUnicodeCharInComment); try { this.declFile = new DeclFileWriter(this.emitOptions.ioHost.createFile(declareFileName, useUTF8InOutputfile)); } catch (ex) { this.errorReporter.emitterError(null, ex.message); } } this.pushDeclarationContainer(moduleDecl); } else { if(!this.emitOptions.outputMany) { TypeScript.CompilerDiagnostics.assert(this.singleDeclFile != this.declFile, "singleDeclFile cannot be null as we are going to revert back to it"); TypeScript.CompilerDiagnostics.assert(this.indenter.indentAmt == 0, "Indent has to be 0 when outputing new file"); try { this.declFile.Close(); } catch (ex) { this.errorReporter.emitterError(null, ex.message); } this.declFile = this.singleDeclFile; } this.popDeclarationContainer(moduleDecl); } } return true; } if(moduleDecl.isEnum()) { if(pre) { this.emitEnumSignature(moduleDecl); } return false; } if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(moduleDecl.modFlags), moduleDecl, pre)) { return false; } if(pre) { if(this.emitDottedModuleName()) { this.dottedModuleEmit += "."; } else { this.dottedModuleEmit = this.getDeclFlagsString(TypeScript.ToDeclFlags(moduleDecl.modFlags), "module"); } this.dottedModuleEmit += moduleDecl.name.text; var isCurrentModuleDotted = (moduleDecl.members.members.length == 1 && moduleDecl.members.members[0].nodeType == TypeScript.NodeType.ModuleDeclaration && !(moduleDecl.members.members[0]).isEnum() && TypeScript.hasFlag((moduleDecl.members.members[0]).modFlags, TypeScript.ModuleFlags.Exported)); var moduleDeclComments = moduleDecl.getDocComments(); isCurrentModuleDotted = isCurrentModuleDotted && (moduleDeclComments == null || moduleDeclComments.length == 0); this.isDottedModuleName.push(isCurrentModuleDotted); this.pushDeclarationContainer(moduleDecl); if(!isCurrentModuleDotted) { this.emitDeclarationComments(moduleDecl); this.declFile.Write(this.dottedModuleEmit); this.declFile.WriteLine(" {"); this.indenter.increaseIndent(); } } else { if(!this.emitDottedModuleName()) { this.indenter.decreaseIndent(); this.emitIndent(); this.declFile.WriteLine("}"); } this.popDeclarationContainer(moduleDecl); this.isDottedModuleName.pop(); } return true; }; DeclarationEmitter.prototype.ScriptCallback = function (pre, script) { if(pre) { if(this.emitOptions.outputMany) { for(var i = 0; i < script.referencedFiles.length; i++) { var referencePath = script.referencedFiles[i].path; var declareFileName; if(TypeScript.isRooted(referencePath)) { declareFileName = this.emitOptions.mapOutputFileName(referencePath, TypeScript.TypeScriptCompiler.mapToDTSFileName); } else { declareFileName = TypeScript.getDeclareFilePath(script.referencedFiles[i].path); } this.declFile.WriteLine('/// '); } } this.pushDeclarationContainer(script); } else { this.popDeclarationContainer(script); } return true; }; DeclarationEmitter.prototype.DefaultCallback = function (pre, ast) { return !TypeScript.hasFlag(ast.flags, TypeScript.ASTFlags.IsStatement); }; return DeclarationEmitter; })(); TypeScript.DeclarationEmitter = DeclarationEmitter; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { (function (UpdateUnitKind) { UpdateUnitKind._map = []; UpdateUnitKind._map[0] = "Unknown"; UpdateUnitKind.Unknown = 0; UpdateUnitKind._map[1] = "NoEdits"; UpdateUnitKind.NoEdits = 1; UpdateUnitKind._map[2] = "EditsInsideSingleScope"; UpdateUnitKind.EditsInsideSingleScope = 2; })(TypeScript.UpdateUnitKind || (TypeScript.UpdateUnitKind = {})); var UpdateUnitKind = TypeScript.UpdateUnitKind; var ScriptEditRange = (function () { function ScriptEditRange(minChar, limChar, delta) { this.minChar = minChar; this.limChar = limChar; this.delta = delta; } ScriptEditRange.unknown = function unknown() { return new ScriptEditRange(-1, -1, -1); } ScriptEditRange.prototype.isUnknown = function () { return this.minChar === -1 && this.limChar === -1 && this.delta === -1; }; ScriptEditRange.prototype.containsPosition = function (pos) { return (this.minChar <= pos && pos < this.limChar) || (this.minChar <= pos && pos < this.limChar + this.delta); }; ScriptEditRange.prototype.toString = function () { return "editRange(minChar=" + this.minChar + ", limChar=" + this.limChar + ", delta=" + this.delta + ")"; }; return ScriptEditRange; })(); TypeScript.ScriptEditRange = ScriptEditRange; var UpdateUnitResult = (function () { function UpdateUnitResult(kind, unitIndex, script1, script2) { this.kind = kind; this.unitIndex = unitIndex; this.script1 = script1; this.script2 = script2; this.scope1 = null; this.scope2 = null; this.editRange = null; this.parseErrors = []; } UpdateUnitResult.noEdits = function noEdits(unitIndex) { return new UpdateUnitResult(UpdateUnitKind.NoEdits, unitIndex, null, null); } UpdateUnitResult.unknownEdits = function unknownEdits(script1, script2, parseErrors) { var result = new UpdateUnitResult(UpdateUnitKind.Unknown, script1.locationInfo.unitIndex, script1, script2); result.parseErrors = parseErrors; return result; } UpdateUnitResult.singleScopeEdits = function singleScopeEdits(script1, script2, scope1, scope2, editRange, parseErrors) { var result = new UpdateUnitResult(UpdateUnitKind.EditsInsideSingleScope, script1.locationInfo.unitIndex, script1, script2); result.scope1 = scope1; result.scope2 = scope2; result.editRange = editRange; result.parseErrors = parseErrors; return result; } return UpdateUnitResult; })(); TypeScript.UpdateUnitResult = UpdateUnitResult; var ErrorEntry = (function () { function ErrorEntry(unitIndex, minChar, limChar, message) { this.unitIndex = unitIndex; this.minChar = minChar; this.limChar = limChar; this.message = message; } return ErrorEntry; })(); TypeScript.ErrorEntry = ErrorEntry; TypeScript.defaultSettings = new TypeScript.CompilationSettings(); var TypeScriptCompiler = (function () { function TypeScriptCompiler(errorOutput, logger, settings) { if (typeof logger === "undefined") { logger = new TypeScript.NullLogger(); } if (typeof settings === "undefined") { settings = TypeScript.defaultSettings; } this.errorOutput = errorOutput; this.logger = logger; this.settings = settings; this.parser = new TypeScript.Parser(); this.typeFlow = null; this.scripts = new TypeScript.ASTList(); this.units = new Array(); this.errorReporter = new TypeScript.ErrorReporter(this.errorOutput); this.persistentTypeState = new TypeScript.PersistentGlobalTypeState(this.errorReporter); this.errorReporter.parser = this.parser; this.initTypeChecker(this.errorOutput); this.parser.style_requireSemi = this.settings.styleSettings.requireSemi; this.parser.style_funcInLoop = this.settings.styleSettings.funcInLoop; this.parser.inferPropertiesFromThisAssignment = this.settings.inferPropertiesFromThisAssignment; this.emitSettings = new TypeScript.EmitOptions(this.settings); TypeScript.codeGenTarget = settings.codeGenTarget; } TypeScriptCompiler.prototype.timeFunction = function (funcDescription, func) { return TypeScript.timeFunction(this.logger, funcDescription, func); }; TypeScriptCompiler.prototype.initTypeChecker = function (errorOutput) { this.persistentTypeState.refreshPersistentState(); this.typeChecker = new TypeScript.TypeChecker(this.persistentTypeState); this.typeChecker.errorReporter = this.errorReporter; this.typeChecker.checkControlFlow = this.settings.controlFlow; this.typeChecker.checkControlFlowUseDef = this.settings.controlFlowUseDef; this.typeChecker.printControlFlowGraph = this.settings.printControlFlow; this.typeChecker.errorsOnWith = this.settings.errorOnWith; this.typeChecker.styleSettings = this.settings.styleSettings; this.typeChecker.canCallDefinitionSignature = this.settings.canCallDefinitionSignature; this.errorReporter.checker = this.typeChecker; this.setErrorOutput(this.errorOutput); }; TypeScriptCompiler.prototype.setErrorOutput = function (outerr) { this.errorOutput = outerr; this.errorReporter.setErrOut(outerr); this.parser.outfile = outerr; }; TypeScriptCompiler.prototype.emitCommentsToOutput = function () { this.emitSettings = new TypeScript.EmitOptions(this.settings); }; TypeScriptCompiler.prototype.setErrorCallback = function (fn) { this.parser.errorCallback = fn; }; TypeScriptCompiler.prototype.updateUnit = function (prog, filename, setRecovery) { return this.updateSourceUnit(new TypeScript.StringSourceText(prog), filename, setRecovery); }; TypeScriptCompiler.prototype.updateSourceUnit = function (sourceText, filename, setRecovery) { var _this = this; return this.timeFunction("updateSourceUnit(" + filename + ")", function () { var updateResult = _this.partialUpdateUnit(sourceText, filename, setRecovery); return _this.applyUpdateResult(updateResult); }); }; TypeScriptCompiler.prototype.applyUpdateResult = function (updateResult) { switch(updateResult.kind) { case UpdateUnitKind.NoEdits: { return false; } case UpdateUnitKind.Unknown: { this.scripts.members[updateResult.unitIndex] = updateResult.script2; this.units[updateResult.unitIndex] = updateResult.script2.locationInfo; for(var i = 0, len = updateResult.parseErrors.length; i < len; i++) { var e = updateResult.parseErrors[i]; if(this.parser.errorCallback) { this.parser.errorCallback(e.minChar, e.limChar - e.minChar, e.message, e.unitIndex); } } return true; } case UpdateUnitKind.EditsInsideSingleScope: { new TypeScript.IncrementalParser(this.logger).mergeTrees(updateResult); return true; } } }; TypeScriptCompiler.prototype.partialUpdateUnit = function (sourceText, filename, setRecovery) { var _this = this; return this.timeFunction("partialUpdateUnit(" + filename + ")", function () { for(var i = 0, len = _this.units.length; i < len; i++) { if(_this.units[i].filename == filename) { if((_this.scripts.members[i]).isResident) { return UpdateUnitResult.noEdits(i); } if(setRecovery) { _this.parser.setErrorRecovery(null); } var updateResult; var parseErrors = []; var errorCapture = function (minChar, charLen, message, unitIndex) { parseErrors.push(new ErrorEntry(unitIndex, minChar, minChar + charLen, message)); }; var svErrorCallback = _this.parser.errorCallback; if(svErrorCallback) { _this.parser.errorCallback = errorCapture; } var oldScript = _this.scripts.members[i]; var newScript = _this.parser.parse(sourceText, filename, i); if(svErrorCallback) { _this.parser.errorCallback = svErrorCallback; } updateResult = UpdateUnitResult.unknownEdits(oldScript, newScript, parseErrors); return updateResult; } } throw new Error("Unknown file \"" + filename + "\""); }); }; TypeScriptCompiler.prototype.addUnit = function (prog, filename, keepResident, referencedFiles) { if (typeof keepResident === "undefined") { keepResident = false; } if (typeof referencedFiles === "undefined") { referencedFiles = []; } return this.addSourceUnit(new TypeScript.StringSourceText(prog), filename, keepResident, referencedFiles); }; TypeScriptCompiler.prototype.addSourceUnit = function (sourceText, filename, keepResident, referencedFiles) { if (typeof referencedFiles === "undefined") { referencedFiles = []; } var _this = this; return this.timeFunction("addSourceUnit(" + filename + ", " + keepResident + ")", function () { var script = _this.parser.parse(sourceText, filename, _this.units.length, TypeScript.AllowedElements.Global); script.referencedFiles = referencedFiles; script.isResident = keepResident; _this.persistentTypeState.setCollectionMode(keepResident ? TypeScript.TypeCheckCollectionMode.Resident : TypeScript.TypeCheckCollectionMode.Transient); var index = _this.units.length; _this.units[index] = script.locationInfo; _this.typeChecker.collectTypes(script); _this.scripts.append(script); return script; }); }; TypeScriptCompiler.prototype.parseUnit = function (prog, filename) { return this.parseSourceUnit(new TypeScript.StringSourceText(prog), filename); }; TypeScriptCompiler.prototype.parseSourceUnit = function (sourceText, filename) { this.parser.setErrorRecovery(this.errorOutput); var script = this.parser.parse(sourceText, filename, 0); var index = this.units.length; this.units[index] = script.locationInfo; this.typeChecker.collectTypes(script); this.scripts.append(script); }; TypeScriptCompiler.prototype.typeCheck = function () { var _this = this; return this.timeFunction("typeCheck()", function () { var binder = new TypeScript.Binder(_this.typeChecker); _this.typeChecker.units = _this.units; binder.bind(_this.typeChecker.globalScope, _this.typeChecker.globals); binder.bind(_this.typeChecker.globalScope, _this.typeChecker.ambientGlobals); binder.bind(_this.typeChecker.globalScope, _this.typeChecker.globalTypes); binder.bind(_this.typeChecker.globalScope, _this.typeChecker.ambientGlobalTypes); _this.typeFlow = new TypeScript.TypeFlow(_this.logger, _this.typeChecker.globalScope, _this.parser, _this.typeChecker); var i = 0; var script = null; var len = _this.scripts.members.length; _this.persistentTypeState.setCollectionMode(TypeScript.TypeCheckCollectionMode.Resident); for(i = 0; i < len; i++) { script = _this.scripts.members[i]; if(!script.isResident || script.hasBeenTypeChecked) { continue; } _this.typeFlow.assignScopes(script); _this.typeFlow.initLibs(); } for(i = 0; i < len; i++) { script = _this.scripts.members[i]; if(!script.isResident || script.hasBeenTypeChecked) { continue; } _this.typeFlow.typeCheck(script); script.hasBeenTypeChecked = true; } _this.persistentTypeState.setCollectionMode(TypeScript.TypeCheckCollectionMode.Transient); len = _this.scripts.members.length; for(i = 0; i < len; i++) { script = _this.scripts.members[i]; if(script.isResident) { continue; } _this.typeFlow.assignScopes(script); _this.typeFlow.initLibs(); } for(i = 0; i < len; i++) { script = _this.scripts.members[i]; if(script.isResident) { continue; } _this.typeFlow.typeCheck(script); } return null; }); }; TypeScriptCompiler.prototype.cleanASTTypesForReTypeCheck = function (ast) { function cleanASTType(ast, parent) { ast.type = null; if(ast.nodeType == TypeScript.NodeType.VarDecl) { var vardecl = ast; vardecl.sym = null; } else { if(ast.nodeType == TypeScript.NodeType.ArgDecl) { var argdecl = ast; argdecl.sym = null; } else { if(ast.nodeType == TypeScript.NodeType.Name) { var name = ast; name.sym = null; } else { if(ast.nodeType == TypeScript.NodeType.FuncDecl) { var funcdecl = ast; funcdecl.signature = null; funcdecl.freeVariables = new Array(); funcdecl.symbols = null; funcdecl.accessorSymbol = null; funcdecl.scopeType = null; } else { if(ast.nodeType == TypeScript.NodeType.ModuleDeclaration) { var modDecl = ast; modDecl.mod = null; } else { if(ast.nodeType == TypeScript.NodeType.With) { (ast).withSym = null; } else { if(ast.nodeType == TypeScript.NodeType.Catch) { (ast).containedScope = null; } } } } } } } return ast; } TypeScript.getAstWalkerFactory().walk(ast, cleanASTType); }; TypeScriptCompiler.prototype.cleanTypesForReTypeCheck = function () { var _this = this; return this.timeFunction("cleanTypesForReTypeCheck()", function () { for(var i = 0, len = _this.scripts.members.length; i < len; i++) { var script = _this.scripts.members[i]; if((script).isResident) { continue; } _this.cleanASTTypesForReTypeCheck(script); _this.typeChecker.collectTypes(script); } return null; }); }; TypeScriptCompiler.prototype.attemptIncrementalTypeCheck = function (updateResult) { return this.timeFunction("attemptIncrementalTypeCheck()", function () { return false; }); }; TypeScriptCompiler.prototype.reTypeCheck = function () { var _this = this; return this.timeFunction("reTypeCheck()", function () { TypeScript.CompilerDiagnostics.analysisPass++; _this.initTypeChecker(_this.errorOutput); _this.persistentTypeState.setCollectionMode(TypeScript.TypeCheckCollectionMode.Transient); _this.cleanTypesForReTypeCheck(); return _this.typeCheck(); }); }; TypeScriptCompiler.prototype.isDynamicModuleCompilation = function () { for(var i = 0, len = this.scripts.members.length; i < len; i++) { var script = this.scripts.members[i]; if(!script.isDeclareFile && script.topLevelMod != null) { return true; } } return false; }; TypeScriptCompiler.prototype.updateCommonDirectoryPath = function () { var commonComponents = []; var commonComponentsLength = -1; for(var i = 0, len = this.scripts.members.length; i < len; i++) { var script = this.scripts.members[i]; if(script.emitRequired(this.emitSettings)) { var fileName = script.locationInfo.filename; var fileComponents = TypeScript.filePathComponents(fileName); if(commonComponentsLength == -1) { commonComponents = fileComponents; commonComponentsLength = commonComponents.length; } else { var updatedPath = false; for(var j = 0; j < commonComponentsLength && j < fileComponents.length; j++) { if(commonComponents[j] != fileComponents[j]) { commonComponentsLength = j; updatedPath = true; if(j == 0) { this.errorReporter.emitterError(null, "Cannot find the common subdirectory path for the input files"); return; } break; } } if(!updatedPath && fileComponents.length < commonComponentsLength) { commonComponentsLength = fileComponents.length; } } } } this.emitSettings.commonDirectoryPath = commonComponents.slice(0, commonComponentsLength).join("/") + "/"; if(this.emitSettings.outputOption.charAt(this.emitSettings.outputOption.length - 1) != "/") { this.emitSettings.outputOption += "/"; } }; TypeScriptCompiler.prototype.parseEmitOption = function (ioHost) { this.emitSettings.ioHost = ioHost; if(this.emitSettings.outputOption == "") { this.emitSettings.outputMany = true; this.emitSettings.commonDirectoryPath = ""; return; } this.emitSettings.outputOption = TypeScript.switchToForwardSlashes(this.emitSettings.ioHost.resolvePath(this.emitSettings.outputOption)); if(this.emitSettings.ioHost.directoryExists(this.emitSettings.outputOption)) { this.emitSettings.outputMany = true; } else { if(this.emitSettings.ioHost.fileExists(this.emitSettings.outputOption)) { this.emitSettings.outputMany = false; } else { this.emitSettings.outputMany = !TypeScript.isJSFile(this.emitSettings.outputOption); } } if(this.isDynamicModuleCompilation() && !this.emitSettings.outputMany) { this.errorReporter.emitterError(null, "Cannot compile dynamic modules when emitting into single file"); } if(this.emitSettings.outputMany) { this.updateCommonDirectoryPath(); } }; TypeScriptCompiler.prototype.useUTF8ForFile = function (script) { if(this.emitSettings.outputMany) { return this.outputScriptToUTF8(script); } else { return this.outputScriptsToUTF8((this.scripts.members)); } }; TypeScriptCompiler.mapToDTSFileName = function mapToDTSFileName(fileName, wholeFileNameReplaced) { return TypeScript.getDeclareFilePath(fileName); } TypeScriptCompiler.prototype.canEmitDeclarations = function (script) { if(!this.settings.generateDeclarationFiles) { return false; } if(!!script && (script.isDeclareFile || script.isResident || script.bod == null)) { return false; } return true; }; TypeScriptCompiler.prototype.emitDeclarationsUnit = function (script, reuseEmitter, declarationEmitter) { if(!this.canEmitDeclarations(script)) { return null; } if(!declarationEmitter) { var declareFileName = this.emitSettings.mapOutputFileName(script.locationInfo.filename, TypeScriptCompiler.mapToDTSFileName); var declareFile = this.createFile(declareFileName, this.useUTF8ForFile(script)); declarationEmitter = new TypeScript.DeclarationEmitter(this.typeChecker, this.emitSettings, this.errorReporter); declarationEmitter.setDeclarationFile(declareFile); } declarationEmitter.emitDeclarations(script); if(!reuseEmitter) { declarationEmitter.Close(); return null; } else { return declarationEmitter; } }; TypeScriptCompiler.prototype.emitDeclarations = function () { if(!this.canEmitDeclarations()) { return; } if(this.errorReporter.hasErrors) { return; } if(this.scripts.members.length == 0) { return; } var declarationEmitter = null; for(var i = 0, len = this.scripts.members.length; i < len; i++) { var script = this.scripts.members[i]; if(this.emitSettings.outputMany || declarationEmitter == null) { declarationEmitter = this.emitDeclarationsUnit(script, !this.emitSettings.outputMany); } else { this.emitDeclarationsUnit(script, true, declarationEmitter); } } if(declarationEmitter) { declarationEmitter.Close(); } }; TypeScriptCompiler.mapToFileNameExtension = function mapToFileNameExtension(extension, fileName, wholeFileNameReplaced) { if(wholeFileNameReplaced) { return fileName; } else { var splitFname = fileName.split("."); splitFname.pop(); return splitFname.join(".") + extension; } } TypeScriptCompiler.mapToJSFileName = function mapToJSFileName(fileName, wholeFileNameReplaced) { return TypeScriptCompiler.mapToFileNameExtension(".js", fileName, wholeFileNameReplaced); } TypeScriptCompiler.prototype.emitUnit = function (script, reuseEmitter, emitter) { if(!script.emitRequired(this.emitSettings)) { return null; } var fname = script.locationInfo.filename; if(!emitter) { var outFname = this.emitSettings.mapOutputFileName(fname, TypeScriptCompiler.mapToJSFileName); var outFile = this.createFile(outFname, this.useUTF8ForFile(script)); emitter = new TypeScript.Emitter(this.typeChecker, outFname, outFile, this.emitSettings, this.errorReporter); if(this.settings.mapSourceFiles) { emitter.setSourceMappings(new TypeScript.SourceMapper(fname, outFname, outFile, this.createFile(outFname + TypeScript.SourceMapper.MapFileExtension, false), this.errorReporter)); } } else { if(this.settings.mapSourceFiles) { emitter.setSourceMappings(new TypeScript.SourceMapper(fname, emitter.emittingFileName, emitter.outfile, emitter.sourceMapper.sourceMapOut, this.errorReporter)); } } this.typeChecker.locationInfo = script.locationInfo; emitter.emitJavascript(script, TypeScript.TokenID.Comma, false); if(!reuseEmitter) { emitter.Close(); return null; } else { return emitter; } }; TypeScriptCompiler.prototype.emit = function (ioHost) { this.parseEmitOption(ioHost); var emitter = null; for(var i = 0, len = this.scripts.members.length; i < len; i++) { var script = this.scripts.members[i]; if(this.emitSettings.outputMany || emitter == null) { emitter = this.emitUnit(script, !this.emitSettings.outputMany); } else { this.emitUnit(script, true, emitter); } } if(emitter) { emitter.Close(); } }; TypeScriptCompiler.prototype.emitToOutfile = function (outputFile) { if(this.settings.mapSourceFiles) { throw Error("Cannot generate source map"); } if(this.settings.generateDeclarationFiles) { throw Error("Cannot generate declaration files"); } if(this.settings.outputOption != "") { throw Error("Cannot parse output option"); } var emitter = emitter = new TypeScript.Emitter(this.typeChecker, "stdout", outputFile, this.emitSettings, this.errorReporter); ; ; for(var i = 0, len = this.scripts.members.length; i < len; i++) { var script = this.scripts.members[i]; this.typeChecker.locationInfo = script.locationInfo; emitter.emitJavascript(script, TypeScript.TokenID.Comma, false); } }; TypeScriptCompiler.prototype.emitAST = function (ioHost) { this.parseEmitOption(ioHost); var outFile = null; var context = null; for(var i = 0, len = this.scripts.members.length; i < len; i++) { var script = this.scripts.members[i]; if(this.emitSettings.outputMany || context == null) { var fname = this.units[i].filename; var mapToTxtFileName = function (fileName, wholeFileNameReplaced) { return TypeScriptCompiler.mapToFileNameExtension(".txt", fileName, wholeFileNameReplaced); }; var outFname = this.emitSettings.mapOutputFileName(fname, mapToTxtFileName); outFile = this.createFile(outFname, this.useUTF8ForFile(script)); context = new TypeScript.PrintContext(outFile, this.parser); } TypeScript.getAstWalkerFactory().walk(script, TypeScript.prePrintAST, TypeScript.postPrintAST, null, context); if(this.emitSettings.outputMany) { try { outFile.Close(); } catch (e) { this.errorReporter.emitterError(null, e.message); } } } if(!this.emitSettings.outputMany) { try { outFile.Close(); } catch (e) { this.errorReporter.emitterError(null, e.message); } } }; TypeScriptCompiler.prototype.outputScriptToUTF8 = function (script) { return script.containsUnicodeChar || (this.emitSettings.emitComments && script.containsUnicodeCharInComment); }; TypeScriptCompiler.prototype.outputScriptsToUTF8 = function (scripts) { for(var i = 0, len = scripts.length; i < len; i++) { var script = scripts[i]; if(this.outputScriptToUTF8(script)) { return true; } } return false; }; TypeScriptCompiler.prototype.createFile = function (fileName, useUTF8) { try { return this.emitSettings.ioHost.createFile(fileName, useUTF8); } catch (ex) { this.errorReporter.emitterError(null, ex.message); } }; return TypeScriptCompiler; })(); TypeScript.TypeScriptCompiler = TypeScriptCompiler; var ScopeEntry = (function () { function ScopeEntry(name, type, sym) { this.name = name; this.type = type; this.sym = sym; } return ScopeEntry; })(); TypeScript.ScopeEntry = ScopeEntry; var ScopeTraversal = (function () { function ScopeTraversal(compiler) { this.compiler = compiler; } ScopeTraversal.prototype.getScope = function (enclosingScopeContext) { if(enclosingScopeContext.enclosingObjectLit && enclosingScopeContext.isMemberCompletion) { return enclosingScopeContext.getObjectLiteralScope(); } else { if(enclosingScopeContext.isMemberCompletion) { if(enclosingScopeContext.useFullAst) { return this.compiler.typeFlow.findMemberScopeAtFullAst(enclosingScopeContext); } else { return this.compiler.typeFlow.findMemberScopeAt(enclosingScopeContext); } } else { return enclosingScopeContext.getScope(); } } }; ScopeTraversal.prototype.getScopeEntries = function (enclosingScopeContext) { var scope = this.getScope(enclosingScopeContext); if(scope == null) { return []; } var inScopeNames = new TypeScript.StringHashTable(); var allSymbolNames = scope.getAllSymbolNames(enclosingScopeContext.isMemberCompletion); for(var i = 0; i < allSymbolNames.length; i++) { var name = allSymbolNames[i]; if(name == TypeScript.globalId || name == "_Core" || name == "_element") { continue; } inScopeNames.add(name, ""); } var svModuleDecl = this.compiler.typeChecker.currentModDecl; this.compiler.typeChecker.currentModDecl = enclosingScopeContext.deepestModuleDecl; var result = this.getTypeNamesForNames(enclosingScopeContext, inScopeNames.getAllKeys(), scope); this.compiler.typeChecker.currentModDecl = svModuleDecl; return result; }; ScopeTraversal.prototype.getTypeNamesForNames = function (enclosingScopeContext, allNames, scope) { var result = []; var enclosingScope = enclosingScopeContext.getScope(); for(var i = 0; i < allNames.length; i++) { var name = allNames[i]; var publicsOnly = enclosingScopeContext.publicsOnly && enclosingScopeContext.isMemberCompletion; var symbol = scope.find(name, publicsOnly, false); if(symbol == null) { symbol = scope.find(name, publicsOnly, true); } var displayThisMember = symbol && symbol.flags & TypeScript.SymbolFlags.Private ? symbol.container == scope.container : true; if(symbol) { if(displayThisMember && !TypeScript.isQuoted(symbol.name) && !TypeScript.isRelative(symbol.name)) { var typeName = symbol.getType().getScopedTypeName(enclosingScope); result.push(new ScopeEntry(name, typeName, symbol)); } } else { if(name == "true" || name == "false") { result.push(new ScopeEntry(name, "bool", this.compiler.typeChecker.booleanType.symbol)); } } } return result; }; return ScopeTraversal; })(); TypeScript.ScopeTraversal = ScopeTraversal; })(TypeScript || (TypeScript = {})); var TypeScript; (function (TypeScript) { (function (CompilerDiagnostics) { CompilerDiagnostics.debug = false; CompilerDiagnostics.diagnosticWriter = null; CompilerDiagnostics.analysisPass = 0; function Alert(output) { if(CompilerDiagnostics.diagnosticWriter) { CompilerDiagnostics.diagnosticWriter.Alert(output); } } CompilerDiagnostics.Alert = Alert; function debugPrint(s) { if(CompilerDiagnostics.debug) { Alert(s); } } CompilerDiagnostics.debugPrint = debugPrint; function assert(condition, s) { if(CompilerDiagnostics.debug) { if(!condition) { Alert(s); } } } CompilerDiagnostics.assert = assert; })(TypeScript.CompilerDiagnostics || (TypeScript.CompilerDiagnostics = {})); var CompilerDiagnostics = TypeScript.CompilerDiagnostics; var NullLogger = (function () { function NullLogger() { } NullLogger.prototype.information = function () { return false; }; NullLogger.prototype.debug = function () { return false; }; NullLogger.prototype.warning = function () { return false; }; NullLogger.prototype.error = function () { return false; }; NullLogger.prototype.fatal = function () { return false; }; NullLogger.prototype.log = function (s) { }; return NullLogger; })(); TypeScript.NullLogger = NullLogger; var LoggerAdapter = (function () { function LoggerAdapter(logger) { this.logger = logger; this._information = this.logger.information(); this._debug = this.logger.debug(); this._warning = this.logger.warning(); this._error = this.logger.error(); this._fatal = this.logger.fatal(); } LoggerAdapter.prototype.information = function () { return this._information; }; LoggerAdapter.prototype.debug = function () { return this._debug; }; LoggerAdapter.prototype.warning = function () { return this._warning; }; LoggerAdapter.prototype.error = function () { return this._error; }; LoggerAdapter.prototype.fatal = function () { return this._fatal; }; LoggerAdapter.prototype.log = function (s) { this.logger.log(s); }; return LoggerAdapter; })(); TypeScript.LoggerAdapter = LoggerAdapter; var BufferedLogger = (function () { function BufferedLogger() { this.logContents = []; } BufferedLogger.prototype.information = function () { return false; }; BufferedLogger.prototype.debug = function () { return false; }; BufferedLogger.prototype.warning = function () { return false; }; BufferedLogger.prototype.error = function () { return false; }; BufferedLogger.prototype.fatal = function () { return false; }; BufferedLogger.prototype.log = function (s) { this.logContents.push(s); }; return BufferedLogger; })(); TypeScript.BufferedLogger = BufferedLogger; function timeFunction(logger, funcDescription, func) { var start = +new Date(); var result = func(); var end = +new Date(); logger.log(funcDescription + " completed in " + (end - start) + " msec"); return result; } TypeScript.timeFunction = timeFunction; function stringToLiteral(value, length) { var result = ""; var addChar = function (index) { var ch = value.charCodeAt(index); switch(ch) { case 9: { result += "\\t"; break; } case 10: { result += "\\n"; break; } case 11: { result += "\\v"; break; } case 12: { result += "\\f"; break; } case 13: { result += "\\r"; break; } case 34: { result += "\\\""; break; } case 39: { result += "\\\'"; break; } case 92: { result += "\\"; break; } default: { result += value.charAt(index); } } }; var tooLong = (value.length > length); if(tooLong) { var mid = length >> 1; for(var i = 0; i < mid; i++) { addChar(i); } result += "(...)"; for(var i = value.length - mid; i < value.length; i++) { addChar(i); } } else { length = value.length; for(var i = 0; i < length; i++) { addChar(i); } } return result; } TypeScript.stringToLiteral = stringToLiteral; })(TypeScript || (TypeScript = {})); var IOUtils; (function (IOUtils) { function createDirectoryStructure(ioHost, dirName) { if(ioHost.directoryExists(dirName)) { return; } var parentDirectory = ioHost.dirName(dirName); if(parentDirectory != "") { createDirectoryStructure(ioHost, parentDirectory); } ioHost.createDirectory(dirName); } function createFileAndFolderStructure(ioHost, fileName, useUTF8) { var path = ioHost.resolvePath(fileName); var dirName = ioHost.dirName(path); createDirectoryStructure(ioHost, dirName); return ioHost.createFile(path, useUTF8); } IOUtils.createFileAndFolderStructure = createFileAndFolderStructure; function throwIOError(message, error) { var errorMessage = message; if(error && error.message) { errorMessage += (" " + error.message); } throw new Error(errorMessage); } IOUtils.throwIOError = throwIOError; })(IOUtils || (IOUtils = {})); var IO = (function () { function getWindowsScriptHostIO() { var fso = new ActiveXObject("Scripting.FileSystemObject"); var streamObjectPool = []; function getStreamObject() { if(streamObjectPool.length > 0) { return streamObjectPool.pop(); } else { return new ActiveXObject("ADODB.Stream"); } } function releaseStreamObject(obj) { streamObjectPool.push(obj); } var args = []; for(var i = 0; i < WScript.Arguments.length; i++) { args[i] = WScript.Arguments.Item(i); } return { readFile: function (path) { try { var streamObj = getStreamObject(); streamObj.Open(); streamObj.Type = 2; streamObj.Charset = 'x-ansi'; streamObj.LoadFromFile(path); var bomChar = streamObj.ReadText(2); streamObj.Position = 0; if((bomChar.charCodeAt(0) == 254 && bomChar.charCodeAt(1) == 255) || (bomChar.charCodeAt(0) == 255 && bomChar.charCodeAt(1) == 254)) { streamObj.Charset = 'unicode'; } else { if(bomChar.charCodeAt(0) == 239 && bomChar.charCodeAt(1) == 187) { streamObj.Charset = 'utf-8'; } } var str = streamObj.ReadText(-1); streamObj.Close(); releaseStreamObject(streamObj); return str; } catch (err) { IOUtils.throwIOError("Error reading file \"" + path + "\".", err); } }, writeFile: function (path, contents) { var file = this.createFile(path); file.Write(contents); file.Close(); }, fileExists: function (path) { return fso.FileExists(path); }, resolvePath: function (path) { return fso.GetAbsolutePathName(path); }, dirName: function (path) { return fso.GetParentFolderName(path); }, findFile: function (rootPath, partialFilePath) { var path = fso.GetAbsolutePathName(rootPath) + "/" + partialFilePath; while(true) { if(fso.FileExists(path)) { try { var content = this.readFile(path); return { content: content, path: path }; } catch (err) { } } else { rootPath = fso.GetParentFolderName(fso.GetAbsolutePathName(rootPath)); if(rootPath == "") { return null; } else { path = fso.BuildPath(rootPath, partialFilePath); } } } }, deleteFile: function (path) { try { if(fso.FileExists(path)) { fso.DeleteFile(path, true); } } catch (e) { IOUtils.throwIOError("Couldn't delete file '" + path + "'.", e); } }, createFile: function (path, useUTF8) { try { var streamObj = getStreamObject(); streamObj.Charset = useUTF8 ? 'utf-8' : 'x-ansi'; streamObj.Open(); return { Write: function (str) { streamObj.WriteText(str, 0); }, WriteLine: function (str) { streamObj.WriteText(str, 1); }, Close: function () { try { streamObj.SaveToFile(path, 2); } catch (saveError) { IOUtils.throwIOError("Couldn't write to file '" + path + "'.", saveError); }finally { if(streamObj.State != 0) { streamObj.Close(); } releaseStreamObject(streamObj); } } }; } catch (creationError) { IOUtils.throwIOError("Couldn't write to file '" + path + "'.", creationError); } }, directoryExists: function (path) { return fso.FolderExists(path); }, createDirectory: function (path) { try { if(!this.directoryExists(path)) { fso.CreateFolder(path); } } catch (e) { IOUtils.throwIOError("Couldn't create directory '" + path + "'.", e); } }, dir: function (path, spec, options) { options = options || { }; function filesInFolder(folder, root) { var paths = []; var fc; if(options.recursive) { fc = new Enumerator(folder.subfolders); for(; !fc.atEnd(); fc.moveNext()) { paths = paths.concat(filesInFolder(fc.item(), root + "/" + fc.item().Name)); } } fc = new Enumerator(folder.files); for(; !fc.atEnd(); fc.moveNext()) { if(!spec || fc.item().Name.match(spec)) { paths.push(root + "/" + fc.item().Name); } } return paths; } var folder = fso.GetFolder(path); var paths = []; return filesInFolder(folder, path); }, print: function (str) { WScript.StdOut.Write(str); }, printLine: function (str) { WScript.Echo(str); }, arguments: args, stderr: WScript.StdErr, stdout: WScript.StdOut, watchFile: null, run: function (source, filename) { try { eval(source); } catch (e) { IOUtils.throwIOError("Error while executing file '" + filename + "'.", e); } }, getExecutingFilePath: function () { return WScript.ScriptFullName; }, quit: function (exitCode) { if (typeof exitCode === "undefined") { exitCode = 0; } try { WScript.Quit(exitCode); } catch (e) { } } }; } ; ; function getNodeIO() { var _fs = require('fs'); var _path = require('path'); var _module = require('module'); return { readFile: function (file) { try { var buffer = _fs.readFileSync(file); switch(buffer[0]) { case 254: { if(buffer[1] == 255) { var i = 0; while((i + 1) < buffer.length) { var temp = buffer[i]; buffer[i] = buffer[i + 1]; buffer[i + 1] = temp; i += 2; } return buffer.toString("ucs2", 2); } break; } case 255: { if(buffer[1] == 254) { return buffer.toString("ucs2", 2); } break; } case 239: { if(buffer[1] == 187) { return buffer.toString("utf8", 3); } } } return buffer.toString(); } catch (e) { IOUtils.throwIOError("Error reading file \"" + file + "\".", e); } }, writeFile: _fs.writeFileSync, deleteFile: function (path) { try { _fs.unlinkSync(path); } catch (e) { IOUtils.throwIOError("Couldn't delete file '" + path + "'.", e); } }, fileExists: function (path) { return _fs.existsSync(path); }, createFile: function (path, useUTF8) { function mkdirRecursiveSync(path) { var stats = _fs.statSync(path); if(stats.isFile()) { IOUtils.throwIOError("\"" + path + "\" exists but isn't a directory.", null); } else { if(stats.isDirectory()) { return; } else { mkdirRecursiveSync(_path.dirname(path)); _fs.mkdirSync(path, 509); } } } mkdirRecursiveSync(_path.dirname(path)); try { var fd = _fs.openSync(path, 'w'); } catch (e) { IOUtils.throwIOError("Couldn't write to file '" + path + "'.", e); } return { Write: function (str) { _fs.writeSync(fd, str); }, WriteLine: function (str) { _fs.writeSync(fd, str + '\r\n'); }, Close: function () { _fs.closeSync(fd); fd = null; } }; }, dir: function dir(path, spec, options) { options = options || { }; function filesInFolder(folder) { var paths = []; var files = _fs.readdirSync(folder); for(var i = 0; i < files.length; i++) { var stat = _fs.statSync(folder + "/" + files[i]); if(options.recursive && stat.isDirectory()) { paths = paths.concat(filesInFolder(folder + "/" + files[i])); } else { if(stat.isFile() && (!spec || files[i].match(spec))) { paths.push(folder + "/" + files[i]); } } } return paths; } return filesInFolder(path); }, createDirectory: function (path) { try { if(!this.directoryExists(path)) { _fs.mkdirSync(path); } } catch (e) { IOUtils.throwIOError("Couldn't create directory '" + path + "'.", e); } }, directoryExists: function (path) { return _fs.existsSync(path) && _fs.lstatSync(path).isDirectory(); }, resolvePath: function (path) { return _path.resolve(path); }, dirName: function (path) { return _path.dirname(path); }, findFile: function (rootPath, partialFilePath) { var path = rootPath + "/" + partialFilePath; while(true) { if(_fs.existsSync(path)) { try { var content = this.readFile(path); return { content: content, path: path }; } catch (err) { } } else { var parentPath = _path.resolve(rootPath, ".."); if(rootPath === parentPath) { return null; } else { rootPath = parentPath; path = _path.resolve(rootPath, partialFilePath); } } } }, print: function (str) { process.stdout.write(str); }, printLine: function (str) { process.stdout.write(str + '\n'); }, arguments: process.argv.slice(2), stderr: { Write: function (str) { process.stderr.write(str); }, WriteLine: function (str) { process.stderr.write(str + '\n'); }, Close: function () { } }, stdout: { Write: function (str) { process.stdout.write(str); }, WriteLine: function (str) { process.stdout.write(str + '\n'); }, Close: function () { } }, watchFile: function (filename, callback) { var firstRun = true; var processingChange = false; var fileChanged = function (curr, prev) { if(!firstRun) { if(curr.mtime < prev.mtime) { return; } _fs.unwatchFile(filename, fileChanged); if(!processingChange) { processingChange = true; callback(filename); setTimeout(function () { processingChange = false; }, 100); } } firstRun = false; _fs.watchFile(filename, { persistent: true, interval: 500 }, fileChanged); }; fileChanged(); return { filename: filename, close: function () { _fs.unwatchFile(filename, fileChanged); } }; }, run: function (source, filename) { require.main.filename = filename; require.main.paths = _module._nodeModulePaths(_path.dirname(_fs.realpathSync(filename))); require.main._compile(source, filename); }, getExecutingFilePath: function () { return process.mainModule.filename; }, quit: process.exit }; } ; ; if(typeof ActiveXObject === "function") { return getWindowsScriptHostIO(); } else { if(typeof require === "function") { return getNodeIO(); } else { return null; } } })(); var OptionsParser = (function () { function OptionsParser(host) { this.host = host; this.DEFAULT_SHORT_FLAG = "-"; this.DEFAULT_LONG_FLAG = "--"; this.unnamed = []; this.options = []; } OptionsParser.prototype.findOption = function (arg) { for(var i = 0; i < this.options.length; i++) { if(arg === this.options[i].short || arg === this.options[i].name) { return this.options[i]; } } return null; }; OptionsParser.prototype.printUsage = function () { this.host.printLine("Syntax: tsc [options] [file ..]"); this.host.printLine(""); this.host.printLine("Examples: tsc hello.ts"); this.host.printLine(" tsc --out foo.js foo.ts"); this.host.printLine(" tsc @args.txt"); this.host.printLine(""); this.host.printLine("Options:"); var output = []; var maxLength = 0; this.options = this.options.sort(function (a, b) { var aName = a.name.toLowerCase(); var bName = b.name.toLowerCase(); if(aName > bName) { return 1; } else { if(aName < bName) { return -1; } else { return 0; } } }); for(var i = 0; i < this.options.length; i++) { var option = this.options[i]; if(option.experimental) { continue; } if(!option.usage) { break; } var usageString = " "; var type = option.type ? " " + option.type.toUpperCase() : ""; if(option.short) { usageString += this.DEFAULT_SHORT_FLAG + option.short + type + ", "; } usageString += this.DEFAULT_LONG_FLAG + option.name + type; output.push([ usageString, option.usage ]); if(usageString.length > maxLength) { maxLength = usageString.length; } } output.push([ " @", "Insert command line options and files from a file." ]); for(var i = 0; i < output.length; i++) { this.host.printLine(output[i][0] + (new Array(maxLength - output[i][0].length + 3)).join(" ") + output[i][1]); } }; OptionsParser.prototype.option = function (name, config, short) { if(!config) { config = short; short = null; } config.name = name; config.short = short; config.flag = false; this.options.push(config); }; OptionsParser.prototype.flag = function (name, config, short) { if(!config) { config = short; short = null; } config.name = name; config.short = short; config.flag = true; this.options.push(config); }; OptionsParser.prototype.parseString = function (argString) { var position = 0; var tokens = argString.match(/\s+|"|[^\s"]+/g); function peek() { return tokens[position]; } function consume() { return tokens[position++]; } function consumeQuotedString() { var value = ''; consume(); var token = peek(); while(token && token !== '"') { consume(); value += token; token = peek(); } consume(); return value; } var args = []; var currentArg = ''; while(position < tokens.length) { var token = peek(); if(token === '"') { currentArg += consumeQuotedString(); } else { if(token.match(/\s/)) { if(currentArg.length > 0) { args.push(currentArg); currentArg = ''; } consume(); } else { consume(); currentArg += token; } } } if(currentArg.length > 0) { args.push(currentArg); } this.parse(args); }; OptionsParser.prototype.parse = function (args) { var position = 0; function consume() { return args[position++]; } while(position < args.length) { var current = consume(); var match = current.match(/^(--?|@)(.*)/); var value = null; if(match) { if(match[1] === '@') { this.parseString(this.host.readFile(match[2])); } else { var arg = match[2]; var option = this.findOption(arg); if(option === null) { this.host.printLine("Unknown option '" + arg + "'"); this.host.printLine("Use the '--help' flag to see options"); } else { if(!option.flag) { value = consume(); } option.set(value); } } } else { this.unnamed.push(current); } } }; return OptionsParser; })(); var CommandLineHost = (function () { function CommandLineHost(compilationSettings) { this.compilationSettings = compilationSettings; this.pathMap = { }; this.resolvedPaths = { }; } CommandLineHost.prototype.getPathIdentifier = function (path) { return this.compilationSettings.useCaseSensitiveFileResolution ? path : path.toLocaleUpperCase(); }; CommandLineHost.prototype.isResolved = function (path) { return this.resolvedPaths[this.getPathIdentifier(this.pathMap[path])] != undefined; }; CommandLineHost.prototype.resolveCompilationEnvironment = function (preEnv, resolver, traceDependencies) { var _this = this; var resolvedEnv = new TypeScript.CompilationEnvironment(preEnv.compilationSettings, preEnv.ioHost); var nCode = preEnv.code.length; var path = ""; var postResolutionError = function (errorFile, errorMessage) { TypeScript.CompilerDiagnostics.debugPrint("Could not resolve file '" + errorFile + "'" + (errorMessage == "" ? "" : ": " + errorMessage)); }; var resolutionDispatcher = { postResolutionError: postResolutionError, postResolution: function (path, code) { var pathId = _this.getPathIdentifier(path); if(!_this.resolvedPaths[pathId]) { resolvedEnv.code.push(code); _this.resolvedPaths[pathId] = true; } } }; for(var i = 0; i < nCode; i++) { path = TypeScript.switchToForwardSlashes(preEnv.ioHost.resolvePath(preEnv.code[i].path)); this.pathMap[preEnv.code[i].path] = path; resolver.resolveCode(path, "", false, resolutionDispatcher); } return resolvedEnv; }; return CommandLineHost; })(); var BatchCompiler = (function () { function BatchCompiler(ioHost) { this.ioHost = ioHost; this.resolvedEnvironment = null; this.hasResolveErrors = false; this.compilerVersion = "0.8.2.0"; this.printedVersion = false; this.compilationSettings = new TypeScript.CompilationSettings(); this.compilationEnvironment = new TypeScript.CompilationEnvironment(this.compilationSettings, this.ioHost); } BatchCompiler.prototype.resolve = function () { var resolver = new TypeScript.CodeResolver(this.compilationEnvironment); var commandLineHost = new CommandLineHost(this.compilationSettings); var ret = commandLineHost.resolveCompilationEnvironment(this.compilationEnvironment, resolver, true); this.hasResolveErrors = false; for(var i = 0; i < this.compilationEnvironment.code.length; i++) { if(!commandLineHost.isResolved(this.compilationEnvironment.code[i].path)) { this.hasResolveErrors = true; var path = this.compilationEnvironment.code[i].path; if(!TypeScript.isSTRFile(path) && !TypeScript.isDSTRFile(path) && !TypeScript.isTSFile(path) && !TypeScript.isDTSFile(path)) { this.ioHost.stderr.WriteLine("Unknown extension for file: \"" + path + "\". Only .ts and .d.ts extensions are allowed."); } else { this.ioHost.stderr.WriteLine("Error reading file \"" + path + "\": File not found"); } } } return ret; }; BatchCompiler.prototype.compile = function () { var _this = this; var compiler; compiler = new TypeScript.TypeScriptCompiler(this.ioHost.stderr, new TypeScript.NullLogger(), this.compilationSettings); compiler.setErrorOutput(this.ioHost.stderr); compiler.setErrorCallback(function (minChar, charLen, message, unitIndex) { compiler.errorReporter.hasErrors = true; var fname = _this.resolvedEnvironment.code[unitIndex].path; var lineCol = { line: -1, col: -1 }; compiler.parser.getSourceLineCol(lineCol, minChar); var msg = fname + " (" + lineCol.line + "," + (lineCol.col + 1) + "): " + message; if(_this.compilationSettings.errorRecovery) { _this.ioHost.stderr.WriteLine(msg); } else { throw new SyntaxError(msg); } }); if(this.compilationSettings.emitComments) { compiler.emitCommentsToOutput(); } var consumeUnit = function (code, addAsResident) { try { if(!_this.compilationSettings.resolve) { code.content = _this.ioHost.readFile(code.path); if(_this.compilationSettings.generateDeclarationFiles) { TypeScript.CompilerDiagnostics.assert(code.referencedFiles == null, "With no resolve option, referenced files need to null"); code.referencedFiles = TypeScript.getReferencedFiles(code); } } if(code.content) { if(_this.compilationSettings.parseOnly) { compiler.parseUnit(code.content, code.path); } else { if(_this.compilationSettings.errorRecovery) { compiler.parser.setErrorRecovery(_this.ioHost.stderr); } compiler.addUnit(code.content, code.path, addAsResident, code.referencedFiles); } } } catch (err) { compiler.errorReporter.hasErrors = true; _this.ioHost.stderr.WriteLine(err.message); } }; for(var iCode = 0; iCode < this.resolvedEnvironment.code.length; iCode++) { if(!this.compilationSettings.parseOnly || (iCode > 0)) { consumeUnit(this.resolvedEnvironment.code[iCode], false); } } var emitterIOHost = { createFile: function (fileName, useUTF8) { return IOUtils.createFileAndFolderStructure(_this.ioHost, fileName, useUTF8); }, directoryExists: this.ioHost.directoryExists, fileExists: this.ioHost.fileExists, resolvePath: this.ioHost.resolvePath }; try { if(!this.compilationSettings.parseOnly) { compiler.typeCheck(); compiler.emit(emitterIOHost); compiler.emitDeclarations(); } else { compiler.emitAST(emitterIOHost); } } catch (err) { compiler.errorReporter.hasErrors = true; if(err.message != "EmitError") { throw err; } } return compiler.errorReporter.hasErrors; }; BatchCompiler.prototype.run = function () { for(var i = 0; i < this.compilationEnvironment.code.length; i++) { var unit = this.compilationEnvironment.code[i]; var outputFileName = unit.path; if(TypeScript.isTSFile(outputFileName)) { outputFileName = outputFileName.replace(/\.ts$/, ".js"); } else { if(TypeScript.isSTRFile(outputFileName)) { outputFileName = outputFileName.replace(/\.str$/, ".js"); } } if(this.ioHost.fileExists(outputFileName)) { var unitRes = this.ioHost.readFile(outputFileName); this.ioHost.run(unitRes, outputFileName); } } }; BatchCompiler.prototype.batchCompile = function () { var _this = this; TypeScript.CompilerDiagnostics.diagnosticWriter = { Alert: function (s) { _this.ioHost.printLine(s); } }; var code; var opts = new OptionsParser(this.ioHost); opts.option('out', { usage: 'Concatenate and emit output to single file | Redirect output structure to the directory', type: 'file|directory', set: function (str) { _this.compilationSettings.outputOption = str; } }); opts.option('style', { usage: 'Select style checking options (examples --style requireSemi:off or --style "eqeqeq;bitwise:off")', experimental: true, set: function (str) { _this.compilationSettings.setStyleOptions(str); } }); opts.flag('sourcemap', { usage: 'Generates corresponding .map file', set: function () { _this.compilationSettings.mapSourceFiles = true; } }); opts.flag('declaration', { usage: 'Generates corresponding .d.ts file', set: function () { _this.compilationSettings.generateDeclarationFiles = true; } }); if(this.ioHost.watchFile) { opts.flag('watch', { usage: 'Watch output files', set: function () { _this.compilationSettings.watch = true; } }, 'w'); } opts.flag('exec', { usage: 'Execute the script after compilation', set: function () { _this.compilationSettings.exec = true; } }, 'e'); opts.flag('parse', { usage: 'Parse only', experimental: true, set: function () { _this.compilationSettings.parseOnly = true; } }); opts.flag('minw', { usage: 'Minimize whitespace', experimental: true, set: function () { _this.compilationSettings.minWhitespace = true; } }, 'mw'); opts.flag('const', { usage: 'Propagate constants to emitted code', experimental: true, set: function () { _this.compilationSettings.propagateConstants = true; } }); opts.flag('errorrecovery', { usage: 'Enable error recovery', experimental: true, set: function () { _this.compilationSettings.errorRecovery = true; } }, 'er'); opts.flag('comments', { usage: 'Emit comments to output', set: function () { _this.compilationSettings.emitComments = true; } }, 'c'); opts.flag('cflow', { usage: 'Control flow', experimental: true, set: function () { _this.compilationSettings.controlFlow = true; } }); opts.flag('cflowp', { usage: 'Print control flow', experimental: true, set: function () { _this.compilationSettings.controlFlow = true; _this.compilationSettings.printControlFlow = true; } }); opts.flag('cflowu', { usage: 'Print Use Def control flow', experimental: true, set: function () { _this.compilationSettings.controlFlow = true; _this.compilationSettings.controlFlowUseDef = true; } }); opts.flag('noerroronwith', { usage: 'Allow with statements', experimental: true, set: function () { _this.compilationSettings.errorOnWith = false; } }); opts.flag('noresolve', { usage: 'Skip resolution and preprocessing', experimental: true, set: function () { _this.compilationSettings.resolve = false; _this.compilationSettings.preprocess = false; } }); opts.flag('debug', { usage: 'Print debug output', experimental: true, set: function () { TypeScript.CompilerDiagnostics.debug = true; } }); opts.flag('canCallDefinitionSignature', { usage: 'Allows you to call the definition signature of an overload group', experimental: true, set: function () { _this.compilationSettings.canCallDefinitionSignature = true; } }); opts.flag('nooptimizemodules', { usage: 'Do not optimize module codegen', experimental: true, set: function () { TypeScript.optimizeModuleCodeGen = false; } }); opts.flag('nolib', { usage: 'Do not include a default lib.d.ts with global declarations', set: function () { _this.compilationSettings.useDefaultLib = false; } }); opts.flag('inferProperties', { usage: 'Infer class properties from top-level assignments to \'this\'', experimental: true, set: function () { _this.compilationSettings.inferPropertiesFromThisAssignment = true; } }); opts.option('target', { usage: 'Specify ECMAScript target version: "ES3" (default), or "ES5"', type: 'VER', set: function (type) { type = type.toLowerCase(); if(type === 'es3') { _this.compilationSettings.codeGenTarget = TypeScript.CodeGenTarget.ES3; } else { if(type === 'es5') { _this.compilationSettings.codeGenTarget = TypeScript.CodeGenTarget.ES5; } else { _this.ioHost.printLine("ECMAScript target version '" + type + "' not supported. Using default 'ES3' code generation"); } } } }); opts.option('module', { usage: 'Specify module code generation: "commonjs" (default) or "amd"', type: 'kind', set: function (type) { type = type.toLowerCase(); if(type === 'commonjs' || type === 'node') { TypeScript.moduleGenTarget = TypeScript.ModuleGenTarget.Synchronous; } else { if(type === 'amd') { TypeScript.moduleGenTarget = TypeScript.ModuleGenTarget.Asynchronous; } else { _this.ioHost.printLine("Module code generation '" + type + "' not supported. Using default 'commonjs' code generation"); } } } }); var printedUsage = false; opts.flag('help', { usage: 'Print this message', set: function () { _this.printVersion(); opts.printUsage(); printedUsage = true; } }, 'h'); opts.flag('useCaseSensitiveFileResolution', { usage: 'Force file resolution to be case sensitive', experimental: true, set: function () { _this.compilationSettings.useCaseSensitiveFileResolution = true; } }); opts.flag('version', { usage: 'Print the compiler\'s version: ' + this.compilerVersion, set: function () { _this.printVersion(); } }, 'v'); opts.parse(this.ioHost.arguments); if(this.compilationSettings.useDefaultLib) { var compilerFilePath = this.ioHost.getExecutingFilePath(); var binDirPath = this.ioHost.dirName(compilerFilePath); var libStrPath = this.ioHost.resolvePath(binDirPath + "/lib.d.ts"); code = new TypeScript.SourceUnit(libStrPath, null); this.compilationEnvironment.code.push(code); } for(var i = 0; i < opts.unnamed.length; i++) { code = new TypeScript.SourceUnit(opts.unnamed[i], null); this.compilationEnvironment.code.push(code); } if(this.compilationEnvironment.code.length == (this.compilationSettings.useDefaultLib ? 1 : 0)) { if(!printedUsage && !this.printedVersion) { this.printVersion(); opts.printUsage(); this.ioHost.quit(1); } return; } var sourceFiles = []; if(this.compilationSettings.watch) { sourceFiles = this.compilationEnvironment.code.slice(0); } this.resolvedEnvironment = this.compilationSettings.resolve ? this.resolve() : this.compilationEnvironment; var hasCompileErrors = this.compile(); var hasErrors = hasCompileErrors || this.hasResolveErrors; if(!hasErrors) { if(this.compilationSettings.exec) { this.run(); } } if(this.compilationSettings.watch) { this.watchFiles(sourceFiles); } else { this.ioHost.quit(hasErrors ? 1 : 0); } }; BatchCompiler.prototype.printVersion = function () { if(!this.printedVersion) { this.ioHost.printLine("Version " + this.compilerVersion); this.printedVersion = true; } }; BatchCompiler.prototype.watchFiles = function (soruceFiles) { var _this = this; if(!this.ioHost.watchFile) { this.ioHost.printLine("Error: Current host does not support -w[atch] option"); return; } var resolvedFiles = []; var watchers = { }; var addWatcher = function (filename) { if(!watchers[filename]) { var watcher = _this.ioHost.watchFile(filename, onWatchedFileChange); watchers[filename] = watcher; } else { throw new Error("Cannot watch file, it is already watched."); } }; var removeWatcher = function (filename) { if(watchers[filename]) { watchers[filename].close(); delete watchers[filename]; } else { throw new Error("Cannot stop watching file, it is not being watched."); } }; var onWatchedFileChange = function () { _this.compilationEnvironment.code = soruceFiles; _this.resolvedEnvironment = _this.compilationSettings.resolve ? _this.resolve() : _this.compilationEnvironment; var oldFiles = resolvedFiles; var newFiles = []; _this.resolvedEnvironment.code.forEach(function (sf) { return newFiles.push(sf.path); }); newFiles = newFiles.sort(); var i = 0, j = 0; while(i < oldFiles.length && j < newFiles.length) { var compareResult = oldFiles[i].localeCompare(newFiles[j]); if(compareResult == 0) { i++; j++; } else { if(compareResult < 0) { removeWatcher(oldFiles[i]); i++; } else { addWatcher(newFiles[j]); j++; } } } for(var k = i; k < oldFiles.length; k++) { removeWatcher(oldFiles[k]); } for(var k = j; k < newFiles.length; k++) { addWatcher(newFiles[k]); } resolvedFiles = newFiles; ; ; _this.ioHost.printLine(""); _this.ioHost.printLine("Recompiling (" + new Date() + "): "); resolvedFiles.forEach(function (f) { return _this.ioHost.printLine(" " + f); }); var hasCompileErrors = _this.compile(); var hasErrors = hasCompileErrors || _this.hasResolveErrors; if(!hasErrors) { if(_this.compilationSettings.exec) { _this.run(); } } }; this.ioHost.stderr = this.ioHost.stdout; this.resolvedEnvironment.code.forEach(function (sf) { resolvedFiles.push(sf.path); addWatcher(sf.path); }); resolvedFiles.sort(); }; return BatchCompiler; })();