diff options
Diffstat (limited to 'js/src/octane/typescript-compiler.js')
-rw-r--r-- | js/src/octane/typescript-compiler.js | 25745 |
1 files changed, 25745 insertions, 0 deletions
diff --git a/js/src/octane/typescript-compiler.js b/js/src/octane/typescript-compiler.js new file mode 100644 index 0000000000..03ba71c97d --- /dev/null +++ b/js/src/octane/typescript-compiler.js @@ -0,0 +1,25745 @@ +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, "<EOF>", 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*<reference\s+path=)('|")(.+?)\2\s*(static=('|")(.+?)\2\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*<amd-dependency\s+path=)('|")(.+?)\2\s*(static=('|")(.+?)\2\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*<implicit-import\s*)*\/>/igm; + var match = implicitImportRegEx.exec(comment); + if(match) { + return true; + } + return false; + } + TypeScript.getImplicitImport = getImplicitImport; + function getStyleSettings(comment, styleSettings) { + var styleRegEx = /^(\/\/\/\s*<style\s+)(([a-zA-Z])+=('|").+('|"))\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*<reference\s+no-default-lib=)('|")(.+?)\2\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('/// <reference path="' + declareFileName + '" />'); + } + } + 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([ + " @<file>", + "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; +})(); + |