diff --git a/bin/lib.d.ts b/bin/lib.d.ts
new file mode 100644
index 0000000..434d230
--- /dev/null
+++ b/bin/lib.d.ts
@@ -0,0 +1,8264 @@
+/* *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+///
+
+////////////////
+/// ECMAScript APIs
+////////////////
+
+declare var NaN: number;
+declare var Infinity: number;
+
+/**
+ * Evaluates JavaScript code and executes it.
+ * @param x A String value that contains valid JavaScript code.
+ */
+declare function eval(x: string): any;
+
+/**
+ * Converts A string to an integer.
+ * @param s A string to convert into a number.
+ * @param radix A value between 2 and 36 that specifies the base of the number in numString.
+ * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.
+ * All other strings are considered decimal.
+ */
+declare function parseInt(s: string, radix?: number): number;
+
+/**
+ * Converts a string to a floating-point number.
+ * @param string A string that contains a floating-point number.
+ */
+declare function parseFloat(string: string): number;
+
+/**
+ * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a number).
+ * @param number A numeric value.
+ */
+declare function isNaN(number: number): bool;
+
+/**
+ * Determines whether a supplied number is finite.
+ * @param number Any numeric value.
+ */
+declare function isFinite(number: number): bool;
+
+/**
+ * Gets the unencoded version of an encoded Uniform Resource Identifier (URI).
+ * @param encodedURI A value representing an encoded URI.
+ */
+declare function decodeURI(encodedURI: string): string;
+
+/**
+ * Gets the unencoded version of an encoded component of a Uniform Resource Identifier (URI).
+ * @param encodedURIComponent A value representing an encoded URI component.
+ */
+declare function decodeURIComponent(encodedURIComponent: string): string;
+
+/**
+ * Encodes a text string as a valid Uniform Resource Identifier (URI)
+ * @param uri A value representing an encoded URI.
+ */
+declare function encodeURI(uri: string): string;
+
+/**
+ * Encodes a text string as a valid component of a Uniform Resource Identifier (URI).
+ * @param uriComponent A value representing an encoded URI component.
+ */
+declare function encodeURIComponent(uriComponent: string): string;
+
+interface PropertyDescriptor {
+ configurable?: bool;
+ enumerable?: bool;
+ value?: any;
+ writable?: bool;
+ get?(): any;
+ set?(v: any): void;
+}
+
+interface PropertyDescriptorMap {
+ [s: string]: PropertyDescriptor;
+}
+
+interface Object {
+ /** Returns a string representation of an object. */
+ toString(): string;
+
+ /** Returns a date converted to a string using the current locale. */
+ toLocaleString(): string;
+
+ /** Returns the primitive value of the specified object. */
+ valueOf(): Object;
+
+ /**
+ * Determines whether an object has a property with the specified name.
+ * @param v A property name.
+ */
+ hasOwnProperty(v: string): bool;
+
+ /**
+ * Determines whether an object exists in another object's prototype chain.
+ * @param v Another object whose prototype chain is to be checked.
+ */
+ isPrototypeOf(v: Object): bool;
+
+ /**
+ * Determines whether a specified property is enumerable.
+ * @param v A property name.
+ */
+ propertyIsEnumerable(v: string): bool;
+
+ [s: string]: any;
+}
+
+/**
+ * Provides functionality common to all JavaScript objects.
+ */
+declare var Object: {
+ new (value?: any): Object;
+ (): any;
+ (value: any): any;
+
+ /** A reference to the prototype for a class of objects. */
+ prototype: Object;
+
+ /**
+ * Returns the prototype of an object.
+ * @param o The object that references the prototype.
+ */
+ getPrototypeOf(o: any): any;
+
+ /**
+ * Gets the own property descriptor of the specified object.
+ * An own property descriptor is one that is defined directly on the object and is not inherited from the object's prototype.
+ * @param o Object that contains the property.
+ * @param p Name of the property.
+ */
+ getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor;
+
+ /**
+ * Returns the names of the own properties of an object. The own properties of an object are those that are defined directly
+ * on that object, and are not inherited from the object's prototype. The properties of an object include both fields (objects) and functions.
+ * @param o Object that contains the own properties.
+ */
+ getOwnPropertyNames(o: any): string[];
+
+ /**
+ * Creates an object that has the specified prototype, and that optionally contains specified properties.
+ * @param o Object to use as a prototype. May be null
+ * @param properties JavaScript object that contains one or more property descriptors.
+ */
+ create(o: any, properties?: PropertyDescriptorMap): any;
+
+ /**
+ * Adds a property to an object, or modifies attributes of an existing property.
+ * @param o Object on which to add or modify the property. This can be a native JavaScript object (that is, a user-defined object or a built in object) or a DOM object.
+ * @param p The property name.
+ * @param attributes Descriptor for the property. It can be for a data property or an accessor property.
+ */
+ defineProperty(o: any, p: string, attributes: PropertyDescriptor): any;
+
+ /**
+ * Adds one or more properties to an object, and/or modifies attributes of existing properties.
+ * @param o Object on which to add or modify the properties. This can be a native JavaScript object or a DOM object.
+ * @param properties JavaScript object that contains one or more descriptor objects. Each descriptor object describes a data property or an accessor property.
+ */
+ defineProperties(o: any, properties: PropertyDescriptorMap): any;
+
+ /**
+ * Prevents the modification of attributes of existing properties, and prevents the addition of new properties.
+ * @param o Object on which to lock the attributes.
+ */
+ seal(o: any): any;
+
+ /**
+ * Prevents the modification of existing property attributes and values, and prevents the addition of new properties.
+ * @param o Object on which to lock the attributes.
+ */
+ freeze(o: any): any;
+
+ /**
+ * Prevents the addition of new properties to an object.
+ * @param o Object to make non-extensible.
+ */
+ preventExtensions(o: any): any;
+
+ /**
+ * Returns true if existing property attributes cannot be modified in an object and new properties cannot be added to the object.
+ * @param o Object to test.
+ */
+ isSealed(o: any): bool;
+
+ /**
+ * Returns true if existing property attributes and values cannot be modified in an object, and new properties cannot be added to the object.
+ * @param o Object to test.
+ */
+ isFrozen(o: any): bool;
+
+ /**
+ * Returns a value that indicates whether new properties can be added to an object.
+ * @param o Object to test.
+ */
+ isExtensible(o: any): bool;
+
+ /**
+ * Returns the names of the enumerable properties and methods of an object.
+ * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+ */
+ keys(o: any): string[];
+}
+
+/**
+ * Creates a new function.
+ */
+interface Function {
+ /**
+ * Calls the function, substituting the specified object for the this value of the function, and the specified array for the arguments of the function.
+ * @param thisArg The object to be used as the this object.
+ * @param argArray A set of arguments to be passed to the function.
+ */
+ apply(thisArg: any, argArray?: any): any;
+
+ /**
+ * Calls a method of an object, substituting another object for the current object.
+ * @param thisArg The object to be used as the current object.
+ * @param argArray A list of arguments to be passed to the method.
+ */
+ call(thisArg: any, ...argArray: any[]): any;
+
+ /**
+ * For a given function, creates a bound function that has the same body as the original function.
+ * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
+ * @param thisArg An object to which the this keyword can refer inside the new function.
+ * @param argArray A list of arguments to be passed to the new function.
+ */
+ bind(thisArg: any, ...argArray: any[]): any;
+
+ prototype: any;
+ length: number;
+
+ // Non-standard extensions
+ arguments: any;
+ caller: Function;
+}
+
+declare var Function: {
+ /**
+ * Creates a new function.
+ * @param args A list of arguments the function accepts.
+ */
+ new (...args: string[]): Function;
+ (...args: string[]): Function;
+ prototype: Function;
+}
+
+interface IArguments {
+ [index: number]: any;
+ length: number;
+ callee: Function;
+}
+
+interface String {
+ /** Returns a string representation of a string. */
+ toString(): string;
+
+ /**
+ * Returns the character at the specified index.
+ * @param pos The zero-based index of the desired character.
+ */
+ charAt(pos: number): string;
+
+ /**
+ * Returns the Unicode value of the character at the specified location.
+ * @param index The zero-based index of the desired character. If there is no character at the specified index, NaN is returned.
+ */
+ charCodeAt(index: number): number;
+
+ /**
+ * Returns a string that contains the concatenation of two or more strings.
+ * @param strings The strings to append to the end of the string.
+ */
+ concat(...strings: string[]): string;
+
+ /**
+ * Returns the position of the first occurrence of a substring.
+ * @param searchString The substring to search for in the string
+ * @param position The index at which to begin searching the String object. If omitted, search starts at the beginning of the string.
+ */
+ indexOf(searchString: string, position?: number): number;
+
+ /**
+ * Returns the last occurrence of a substring in the string.
+ * @param searchString The substring to search for.
+ * @param position The index at which to begin searching. If omitted, the search begins at the end of the string.
+ */
+ lastIndexOf(searchString: string, position?: number): number;
+
+ /**
+ * Determines whether two strings are equivalent in the current locale.
+ * @param that String to compare to target string
+ */
+ localeCompare(that: string): number;
+
+ /**
+ * Matches a string with a regular expression, and returns an array containing the results of that search.
+ * @param regexp A variable name or string literal containing the regular expression pattern and flags.
+ */
+ match(regexp: string): string[];
+ /**
+ * Matches a string with a regular expression, and returns an array containing the results of that search.
+ * @param regexp A regular expression object that contains the regular expression pattern and applicable flags.
+ */
+ match(regexp: RegExp): string[];
+
+ /**
+ * Replaces text in a string, using a regular expression or search string.
+ * @param searchValue A String object or string literal that represents the regular expression
+ * @param replaceValue A String object or string literal containing the text to replace for every successful match of rgExp in stringObj.
+ */
+ replace(searchValue: string, replaceValue: string): string;
+ /**
+ * Replaces text in a string, using a regular expression or search string.
+ * @param searchValue A String object or string literal that represents the regular expression
+ * @param replaceValue A function that returns the replacement text.
+ */
+ replace(searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string;
+ /**
+ * Replaces text in a string, using a regular expression or search string.
+ * @param searchValue A Regular Expression object containing the regular expression pattern and applicable flags
+ * @param replaceValue A String object or string literal containing the text to replace for every successful match of rgExp in stringObj.
+ */
+ replace(searchValue: RegExp, replaceValue: string): string;
+ /**
+ * Replaces text in a string, using a regular expression or search string.
+ * @param searchValue A Regular Expression object containing the regular expression pattern and applicable flags
+ * @param replaceValue A function that returns the replacement text.
+ */
+ replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string;
+
+ /**
+ * Finds the first substring match in a regular expression search.
+ * @param regexp The regular expression pattern and applicable flags.
+ */
+ search(regexp: string): number;
+ /**
+ * Finds the first substring match in a regular expression search.
+ * @param regexp The regular expression pattern and applicable flags.
+ */
+ search(regexp: RegExp): number;
+
+ /**
+ * Returns a section of a string.
+ * @param start The index to the beginning of the specified portion of stringObj.
+ * @param end The index to the end of the specified portion of stringObj. The substring includes the characters up to, but not including, the character indicated by end.
+ * If this value is not specified, the substring continues to the end of stringObj.
+ */
+ slice(start: number, end?: number): string;
+
+ /**
+ * Split a string into substrings using the specified separator and return them as an array.
+ * @param separator A string that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned.
+ * @param limit A value used to limit the number of elements returned in the array.
+ */
+ split(separator: string, limit?: number): string[];
+ /**
+ * Split a string into substrings using the specified separator and return them as an array.
+ * @param separator A Regular Express that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned.
+ * @param limit A value used to limit the number of elements returned in the array.
+ */
+ split(separator: RegExp, limit?: number): string[];
+
+ /**
+ * Returns the substring at the specified location within a String object.
+ * @param start The zero-based index integer indicating the beginning of the substring.
+ * @param end Zero-based index integer indicating the end of the substring. The substring includes the characters up to, but not including, the character indicated by end.
+ * If end is omitted, the characters from start through the end of the original string are returned.
+ */
+ substring(start: number, end?: number): string;
+
+ /** Converts all the alphabetic characters in a string to lowercase. */
+ toLowerCase(): string;
+
+ /** Converts all alphabetic characters to lowercase, taking into account the host environment's current locale. */
+ toLocaleLowerCase(): string;
+
+ /** Converts all the alphabetic characters in a string to uppercase. */
+ toUpperCase(): string;
+
+ /** Returns a string where all alphabetic characters have been converted to uppercase, taking into account the host environment's current locale. */
+ toLocaleUpperCase(): string;
+
+ /** Removes the leading and trailing white space and line terminator characters from a string. */
+ trim(): string;
+
+ /** Returns the length of a String object. */
+ length: number;
+
+ // IE extensions
+ /**
+ * Gets a substring beginning at the specified location and having the specified length.
+ * @param from The starting position of the desired substring. The index of the first character in the string is zero.
+ * @param length The number of characters to include in the returned substring.
+ */
+ substr(from: number, length?: number): string;
+}
+
+/**
+ * Allows manipulation and formatting of text strings and determination and location of substrings within strings.
+ */
+declare var String: {
+ new (value?: any): String;
+ (value?: any): string;
+ prototype: String;
+ fromCharCode(...codes: number[]): string;
+}
+
+interface Boolean {
+}
+declare var Boolean: {
+ new (value?: any): Boolean;
+ (value?: any): bool;
+ prototype: Boolean;
+}
+
+interface Number {
+ toString(radix?: number): string;
+ toFixed(fractionDigits?: number): string;
+ toExponential(fractionDigits?: number): string;
+ toPrecision(precision: number): string;
+}
+/** An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers. */
+declare var Number: {
+ new (value?: any): Number;
+ (value?: any): number;
+ prototype: Number;
+ /** The largest number that can be represented in JavaScript. Equal to approximately 1.79E+308. */
+ MAX_VALUE: number;
+ /** The closest number to zero that can be represented in JavaScript. Equal to approximately 5.00E-324. */
+ MIN_VALUE: number;
+ /**
+ * A value that is not a number.
+ * In equality comparisons, NaN does not equal any value, including itself. To test whether a value is equivalent to NaN, use the isNaN function.
+ */
+ NaN: number;
+ /**
+ * A value that is less than the largest negative number that can be represented in JavaScript.
+ * JavaScript displays NEGATIVE_INFINITY values as -infinity.
+ */
+ NEGATIVE_INFINITY: number;
+ /**
+ * A value greater than the largest number that can be represented in JavaScript.
+ * JavaScript displays POSITIVE_INFINITY values as infinity.
+ */
+ POSITIVE_INFINITY: number;
+}
+
+interface Math {
+ /** The mathematical constant e. This is Euler's number, the base of natural logarithms. */
+ E: number;
+ /** The natural logarithm of 10. */
+ LN10: number;
+ /** The natural logarithm of 2. */
+ LN2: number;
+ /** The base-2 logarithm of e. */
+ LOG2E: number;
+ /** The base-10 logarithm of e. */
+ LOG10E: number;
+ /** Pi. This is the ratio of the circumference of a circle to its diameter. */
+ PI: number;
+ /** The square root of 0.5, or, equivalently, one divided by the square root of 2. */
+ SQRT1_2: number;
+ /** The square root of 2. */
+ SQRT2: number;
+ /**
+ * Returns the absolute value of a number (the value without regard to whether it is positive or negative).
+ * For example, the absolute value of -5 is the same as the absolute value of 5.
+ * @param x A numeric expression for which the absolute value is needed.
+ */
+ abs(x: number): number;
+ /**
+ * Returns the arc cosine (or inverse cosine) of a number.
+ * @param x A numeric expression.
+ */
+ acos(x: number): number;
+ /**
+ * Returns the arcsine of a number.
+ * @param x A numeric expression.
+ */
+ asin(x: number): number;
+ /**
+ * Returns the arctangent of a number.
+ * @param x A numeric expression for which the arctangent is needed.
+ */
+ atan(x: number): number;
+ /**
+ * Returns the angle (in radians) from the X axis to a point (y,x).
+ * @param y A numeric expression representing the cartesian y-coordinate.
+ * @param x A numeric expression representing the cartesian x-coordinate.
+ */
+ atan2(y: number, x: number): number;
+ /**
+ * Returns the smallest integer greater than or equal to its numeric argument.
+ * @param x A numeric expression.
+ */
+ ceil(x: number): number;
+ /**
+ * Returns the cosine of a number.
+ * @param x A numeric expression that contains an angle measured in radians.
+ */
+ cos(x: number): number;
+ /**
+ * Returns e (the base of natural logarithms) raised to a power.
+ * @param x A numeric expression representing the power of e.
+ */
+ exp(x: number): number;
+ /**
+ * Returns the greatest integer less than or equal to its numeric argument.
+ * @param x A numeric expression.
+ */
+ floor(x: number): number;
+ /**
+ * Returns the natural logarithm (base e) of a number.
+ * @param x A numeric expression.
+ */
+ log(x: number): number;
+ /**
+ * Returns the larger of a set of supplied numeric expressions.
+ * @param values Numeric expressions to be evaluated.
+ */
+ max(...values: number[]): number;
+ /**
+ * Returns the smaller of a set of supplied numeric expressions.
+ * @param values Numeric expressions to be evaluated.
+ */
+ min(...values: number[]): number;
+ /**
+ * Returns the value of a base expression taken to a specified power.
+ * @param x The base value of the expression.
+ * @param y The exponent value of the expression.
+ */
+ pow(x: number, y: number): number;
+ /** Returns a pseudorandom number between 0 and 1. */
+ random(): number;
+ /**
+ * Returns a supplied numeric expression rounded to the nearest integer.
+ * @param x The value to be rounded to the nearest integer.
+ */
+ round(x: number): number;
+ /**
+ * Returns the sine of a number.
+ * @param x A numeric expression that contains an angle measured in radians.
+ */
+ sin(x: number): number;
+ /**
+ * Returns the square root of a number.
+ * @param x A numeric expression.
+ */
+ sqrt(x: number): number;
+ /**
+ * Returns the tangent of a number.
+ * @param x A numeric expression that contains an angle measured in radians.
+ */
+ tan(x: number): number;
+}
+/** An intrinsic object that provides basic mathematics functionality and constants. */
+declare var Math: Math;
+
+/** Enables basic storage and retrieval of dates and times. */
+interface Date {
+ /** Returns a string representation of a date. The format of the string depends on the locale. */
+ toString(): string;
+ /** Returns a date as a string value. */
+ toDateString(): string;
+ /** Returns a time as a string value. */
+ toTimeString(): string;
+ toLocaleString(): string;
+ /** Returns a date as a string value appropriate to the host environment's current locale. */
+ toLocaleDateString(): string;
+ /** Returns a time as a string value appropriate to the host environment's current locale. */
+ toLocaleTimeString(): string;
+ /** Returns the stored time value in milliseconds since midnight, January 1, 1970 UTC. */
+ valueOf(): number;
+ /** Gets the time value in milliseconds. */
+ getTime(): number;
+ /** Gets the year, using local time. */
+ getFullYear(): number;
+ /** Gets the year using Universal Coordinated Time (UTC). */
+ getUTCFullYear(): number;
+ /** Gets the month, using local time. */
+ getMonth(): number;
+ /** Gets the month of a Date object using Universal Coordinated Time (UTC). */
+ getUTCMonth(): number;
+ /** Gets the day-of-the-month, using local time. */
+ getDate(): number;
+ /** Gets the day-of-the-month, using Universal Coordinated Time (UTC). */
+ getUTCDate(): number;
+ /** Gets the day of the week, using local time. */
+ getDay(): number;
+ /** Gets the day of the week using Universal Coordinated Time (UTC). */
+ getUTCDay(): number;
+ /** Gets the hours in a date, using local time. */
+ getHours(): number;
+ /** Gets the hours value in a Date object using Universal Coordinated Time (UTC). */
+ getUTCHours(): number;
+ /** Gets the minutes of a Date object, using local time. */
+ getMinutes(): number;
+ /** Gets the minutes of a Date object using Universal Coordinated Time (UTC). */
+ getUTCMinutes(): number;
+ /** Gets the seconds of a Date object, using local time. */
+ getSeconds(): number;
+ /** Gets the seconds of a Date object using Universal Coordinated Time (UTC). */
+ getUTCSeconds(): number;
+ /** Gets the milliseconds of a Date, using local time. */
+ getMilliseconds(): number;
+ /** Gets the milliseconds of a Date object using Universal Coordinated Time (UTC). */
+ getUTCMilliseconds(): number;
+ /** Gets the difference in minutes between the time on the local computer and Universal Coordinated Time (UTC). */
+ getTimezoneOffset(): number;
+ /**
+ * Sets the date and time value in the Date object.
+ * @param time A numeric value representing the number of elapsed milliseconds since midnight, January 1, 1970 GMT.
+ */
+ setTime(time: number): void;
+ /**
+ * Sets the milliseconds value in the Date object using local time.
+ * @param ms A numeric value equal to the millisecond value.
+ */
+ setMilliseconds(ms: number): void;
+ /**
+ * Sets the milliseconds value in the Date object using Universal Coordinated Time (UTC).
+ * @param ms A numeric value equal to the millisecond value.
+ */
+ setUTCMilliseconds(ms: number): void;
+
+ /**
+ * Sets the seconds value in the Date object using local time.
+ * @param sec A numeric value equal to the seconds value.
+ * @param ms A numeric value equal to the milliseconds value.
+ */
+ setSeconds(sec: number, ms?: number): void;
+ /**
+ * Sets the seconds value in the Date object using Universal Coordinated Time (UTC).
+ * @param sec A numeric value equal to the seconds value.
+ * @param ms A numeric value equal to the milliseconds value.
+ */
+ setUTCSeconds(sec: number, ms?: number): void;
+ /**
+ * Sets the minutes value in the Date object using local time.
+ * @param min A numeric value equal to the minutes value.
+ * @param sec A numeric value equal to the seconds value.
+ * @param ms A numeric value equal to the milliseconds value.
+ */
+ setMinutes(min: number, sec?: number, ms?: number): void;
+ /**
+ * Sets the minutes value in the Date object using Universal Coordinated Time (UTC).
+ * @param min A numeric value equal to the minutes value.
+ * @param sec A numeric value equal to the seconds value.
+ * @param ms A numeric value equal to the milliseconds value.
+ */
+ setUTCMinutes(min: number, sec?: number, ms?: number): void;
+ /**
+ * Sets the hour value in the Date object using local time.
+ * @param hours A numeric value equal to the hours value.
+ * @param min A numeric value equal to the minutes value.
+ * @param sec A numeric value equal to the seconds value.
+ * @param ms A numeric value equal to the milliseconds value.
+ */
+ setHours(hours: number, min?: number, sec?: number, ms?: number): void;
+ /**
+ * Sets the hours value in the Date object using Universal Coordinated Time (UTC).
+ * @param hours A numeric value equal to the hours value.
+ * @param min A numeric value equal to the minutes value.
+ * @param sec A numeric value equal to the seconds value.
+ * @param ms A numeric value equal to the milliseconds value.
+ */
+ setUTCHours(hours: number, min?: number, sec?: number, ms?: number): void;
+ /**
+ * Sets the numeric day-of-the-month value of the Date object using local time.
+ * @param date A numeric value equal to the day of the month.
+ */
+ setDate(date: number): void;
+ /**
+ * Sets the numeric day of the month in the Date object using Universal Coordinated Time (UTC).
+ * @param date A numeric value equal to the day of the month.
+ */
+ setUTCDate(date: number): void;
+ /**
+ * Sets the month value in the Date object using local time.
+ * @param month A numeric value equal to the month. The value for January is 0, and other month values follow consecutively.
+ * @param date A numeric value representing the day of the month. If this value is not supplied, the value from a call to the getDate method is used.
+ */
+ setMonth(month: number, date?: number): void;
+ /**
+ * Sets the month value in the Date object using Universal Coordinated Time (UTC).
+ * @param month A numeric value equal to the month. The value for January is 0, and other month values follow consecutively.
+ * @param date A numeric value representing the day of the month. If it is not supplied, the value from a call to the getUTCDate method is used.
+ */
+ setUTCMonth(month: number, date?: number): void;
+ /**
+ * Sets the year of the Date object using local time.
+ * @param year A numeric value for the year.
+ * @param month A zero-based numeric value for the month (0 for January, 11 for December). Must be specified if numDate is specified.
+ * @param date A numeric value equal for the day of the month.
+ */
+ setFullYear(year: number, month?: number, date?: number): void;
+ /**
+ * Sets the year value in the Date object using Universal Coordinated Time (UTC).
+ * @param year A numeric value equal to the year.
+ * @param month A numeric value equal to the month. The value for January is 0, and other month values follow consecutively. Must be supplied if numDate is supplied.
+ * @param date A numeric value equal to the day of the month.
+ */
+ setUTCFullYear(year: number, month?: number, date?: number): void;
+ /** Returns a date converted to a string using Universal Coordinated Time (UTC). */
+ toUTCString(): string;
+ /** Returns a date as a string value in ISO format. */
+ toISOString(): string;
+ /** Used by the JSON.stringify method to enable the transformation of an object's data for JavaScript Object Notation (JSON) serialization. */
+ toJSON(key?: any): string;
+}
+/**
+ * Enables basic storage and retrieval of dates and times.
+ */
+declare var Date: {
+ new (): Date;
+ new (value: number): Date;
+ new (value: string): Date;
+ new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date;
+ (): string;
+ prototype: Date;
+ /**
+ * Parses a string containing a date, and returns the number of milliseconds between that date and midnight, January 1, 1970.
+ * @param s A date string
+ */
+ parse(s: string): number;
+ /**
+ * Returns the number of milliseconds between midnight, January 1, 1970 Universal Coordinated Time (UTC) (or GMT) and the specified date.
+ * @param year The full year designation is required for cross-century date accuracy. If year is between 0 and 99 is used, then year is assumed to be 1900 + year.
+ * @param month The month as an integer between 0 and 11 (January to December).
+ * @param date The date as an integer between 1 and 31.
+ * @param hours Must be supplied if minutes is supplied. An integer from 0 to 23 (midnight to 11pm) that specifies the hour.
+ * @param minutes Must be supplied if seconds is supplied. An integer from 0 to 59 that specifies the minutes.
+ * @param seconds Must be supplied if milliseconds is supplied. An integer from 0 to 59 that specifies the seconds.
+ * @param ms An integer from 0 to 999 that specifies the milliseconds.
+ */
+ UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
+ now(): number;
+}
+
+interface RegExpExecArray {
+ [index: number]: string;
+ length: number;
+
+ index: number;
+ input: string;
+
+ toString(): string;
+ toLocaleString(): string;
+ concat(...items: string[][]): string[];
+ join(seperator?: string): string;
+ pop(): string;
+ push(...items: string[]): number;
+ reverse(): string[];
+ shift(): string;
+ slice(start: number, end?: number): string[];
+ sort(compareFn?: (a: string, b: string) => number): string[];
+ splice(start: number): string[];
+ splice(start: number, deleteCount: number, ...items: string[]): string[];
+ unshift(...items: string[]): number;
+
+ indexOf(searchElement: string, fromIndex?: number): number;
+ lastIndexOf(searchElement: string, fromIndex?: number): number;
+ every(callbackfn: (value: string, index: number, array: string[]) => bool, thisArg?: any): bool;
+ some(callbackfn: (value: string, index: number, array: string[]) => bool, thisArg?: any): bool;
+ forEach(callbackfn: (value: string, index: number, array: string[]) => void , thisArg?: any): void;
+ map(callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): any[];
+ filter(callbackfn: (value: string, index: number, array: string[]) => bool, thisArg?: any): string[];
+ reduce(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: string[]) => any, initialValue?: any): any;
+ reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: string[]) => any, initialValue?: any): any;
+}
+
+
+interface RegExp {
+ /**
+ * Executes a search on a string using a regular expression pattern, and returns an array containing the results of that search.
+ * @param string The String object or string literal on which to perform the search.
+ */
+ exec(string: string): RegExpExecArray;
+ /**
+ * Returns a Boolean value that indicates whether or not a pattern exists in a searched string.
+ * @param string String on which to perform the search.
+ */
+ test(string: string): bool;
+ /** Returns a copy of the text of the regular expression pattern. Read-only. The rgExp argument is a Regular expression object. It can be a variable name or a literal. */
+ source: string;
+ /** Returns a Boolean value indicating the state of the global flag (g) used with a regular expression. Default is false. Read-only. */
+ global: bool;
+ /** Returns a Boolean value indicating the state of the ignoreCase flag (i) used with a regular expression. Default is false. Read-only. */
+ ignoreCase: bool;
+ /** Returns a Boolean value indicating the state of the multiline flag (m) used with a regular expression. Default is false. Read-only. */
+ multiline: bool;
+
+ lastIndex: number;
+
+ // Non-standard extensions
+ compile(): RegExp;
+}
+declare var RegExp: {
+ new (pattern: string, flags?: string): RegExp;
+ (pattern: string, flags?: string): RegExp;
+
+ // Non-standard extensions
+ $1: string;
+ $2: string;
+ $3: string;
+ $4: string;
+ $5: string;
+ $6: string;
+ $7: string;
+ $8: string;
+ $9: string;
+ lastMatch: string;
+}
+
+interface Error {
+ name: string;
+ message: string;
+}
+declare var Error: {
+ new (message?: string): Error;
+ (message?: string): Error;
+ prototype: Error;
+}
+
+interface EvalError extends Error {
+}
+declare var EvalError: {
+ new (message?: string): EvalError;
+ (message?: string): EvalError;
+ prototype: EvalError;
+}
+
+interface RangeError extends Error {
+}
+declare var RangeError: {
+ new (message?: string): RangeError;
+ (message?: string): RangeError;
+ prototype: RangeError;
+}
+
+interface ReferenceError extends Error {
+}
+declare var ReferenceError: {
+ new (message?: string): ReferenceError;
+ (message?: string): ReferenceError;
+ prototype: ReferenceError;
+}
+
+interface SyntaxError extends Error {
+}
+declare var SyntaxError: {
+ new (message?: string): SyntaxError;
+ (message?: string): SyntaxError;
+ prototype: SyntaxError;
+}
+
+interface TypeError extends Error {
+}
+declare var TypeError: {
+ new (message?: string): TypeError;
+ (message?: string): TypeError;
+ prototype: TypeError;
+}
+
+interface URIError extends Error {
+}
+declare var URIError: {
+ new (message?: string): URIError;
+ (message?: string): URIError;
+ prototype: URIError;
+}
+
+interface JSON {
+ /**
+ * Converts a JavaScript Object Notation (JSON) string into an object.
+ * @param text A valid JSON string.
+ * @param reviver A function that transforms the results. This function is called for each member of the object.
+ * If a member contains nested objects, the nested objects are transformed before the parent object is.
+ */
+ parse(text: string, reviver?: (key: any, value: any) => any): any;
+ /**
+ * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ */
+ stringify(value: any): string;
+ /**
+ * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer A function that transforms the results.
+ */
+ stringify(value: any, replacer: (key: string, value: any) => any): string;
+ /**
+ * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer Array that transforms the results.
+ */
+ stringify(value: any, replacer: any[]): string;
+ /**
+ * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer A function that transforms the results.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ */
+ stringify(value: any, replacer: (key: string, value: any) => any, space: any): string;
+ /**
+ * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer Array that transforms the results.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ */
+ stringify(value: any, replacer: any[], space: any): string;
+}
+/**
+ * An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
+ */
+declare var JSON: JSON;
+
+////////////////
+/// ECMAScript Array API (specially handled by compiler)
+////////////////
+
+interface Array {
+ toString(): string;
+ toLocaleString(): string;
+ concat(...items: _element[][]): _element[];
+ concat(...items: _element[]): _element[];
+ join(seperator?: string): string;
+ pop(): _element;
+ push(...items: _element[]): number;
+ reverse(): _element[];
+ shift(): _element;
+ slice(start: number, end?: number): _element[];
+ sort(compareFn?: (a: _element, b: _element) => number): _element[];
+ splice(start: number): _element[];
+ splice(start: number, deleteCount: number, ...items: _element[]): _element[];
+ unshift(...items: _element[]): number;
+
+ indexOf(searchElement: _element, fromIndex?: number): number;
+ lastIndexOf(searchElement: _element, fromIndex?: number): number;
+ every(callbackfn: (value: _element, index: number, array: _element[]) => bool, thisArg?: any): bool;
+ some(callbackfn: (value: _element, index: number, array: _element[]) => bool, thisArg?: any): bool;
+ forEach(callbackfn: (value: _element, index: number, array: _element[]) => void , thisArg?: any): void;
+ map(callbackfn: (value: _element, index: number, array: _element[]) => any, thisArg?: any): any[];
+ filter(callbackfn: (value: _element, index: number, array: _element[]) => bool, thisArg?: any): _element[];
+ reduce(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: _element[]) => any, initialValue?: any): any;
+ reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: _element[]) => any, initialValue?: any): any;
+
+ length: number;
+}
+declare var Array: {
+ new (...items: any[]): any[];
+ (...items: any[]): any[];
+ isArray(arg: any): bool;
+ prototype: Array;
+}
+
+////////////////
+/// IE10 ECMAScript Extensions
+////////////////
+
+interface ArrayBuffer {
+ byteLength: number;
+}
+declare var ArrayBuffer: {
+ prototype: ArrayBuffer;
+ new (byteLength: number);
+}
+
+interface ArrayBufferView {
+ buffer: ArrayBuffer;
+ byteOffset: number;
+ byteLength: number;
+}
+
+interface Int8Array extends ArrayBufferView {
+ BYTES_PER_ELEMENT: number;
+ length: number;
+ [index: number]: number;
+ get(index: number): number;
+ set(index: number, value: number): void;
+ set(array: Int8Array, offset?: number): void;
+ set(array: number[], offset?: number): void;
+ subarray(begin: number, end?: number): Int8Array;
+}
+declare var Int8Array: {
+ prototype: Int8Array;
+ new (length: number): Int8Array;
+ new (array: Int8Array): Int8Array;
+ new (array: number[]): Int8Array;
+ new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int8Array;
+ BYTES_PER_ELEMENT: number;
+}
+
+interface Uint8Array extends ArrayBufferView {
+ BYTES_PER_ELEMENT: number;
+ length: number;
+ [index: number]: number;
+ get(index: number): number;
+ set(index: number, value: number): void;
+ set(array: Uint8Array, offset?: number): void;
+ set(array: number[], offset?: number): void;
+ subarray(begin: number, end?: number): Uint8Array;
+}
+declare var Uint8Array: {
+ prototype: Uint8Array;
+ new (length: number): Uint8Array;
+ new (array: Uint8Array): Uint8Array;
+ new (array: number[]): Uint8Array;
+ new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint8Array;
+ BYTES_PER_ELEMENT: number;
+}
+
+interface Int16Array extends ArrayBufferView {
+ BYTES_PER_ELEMENT: number;
+ length: number;
+ [index: number]: number;
+ get(index: number): number;
+ set(index: number, value: number): void;
+ set(array: Int16Array, offset?: number): void;
+ set(array: number[], offset?: number): void;
+ subarray(begin: number, end?: number): Int16Array;
+}
+declare var Int16Array: {
+ prototype: Int16Array;
+ new (length: number): Int16Array;
+ new (array: Int16Array): Int16Array;
+ new (array: number[]): Int16Array;
+ new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int16Array;
+ BYTES_PER_ELEMENT: number;
+}
+
+interface Uint16Array extends ArrayBufferView {
+ BYTES_PER_ELEMENT: number;
+ length: number;
+ [index: number]: number;
+ get(index: number): number;
+ set(index: number, value: number): void;
+ set(array: Uint16Array, offset?: number): void;
+ set(array: number[], offset?: number): void;
+ subarray(begin: number, end?: number): Uint16Array;
+}
+declare var Uint16Array: {
+ prototype: Uint16Array;
+ new (length: number): Uint16Array;
+ new (array: Uint16Array): Uint16Array;
+ new (array: number[]): Uint16Array;
+ new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint16Array;
+ BYTES_PER_ELEMENT: number;
+}
+
+interface Int32Array extends ArrayBufferView {
+ BYTES_PER_ELEMENT: number;
+ length: number;
+ [index: number]: number;
+ get(index: number): number;
+ set(index: number, value: number): void;
+ set(array: Int32Array, offset?: number): void;
+ set(array: number[], offset?: number): void;
+ subarray(begin: number, end?: number): Int32Array;
+}
+declare var Int32Array: {
+ prototype: Int32Array;
+ new (length: number): Int32Array;
+ new (array: Int32Array): Int32Array;
+ new (array: number[]): Int32Array;
+ new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int32Array;
+ BYTES_PER_ELEMENT: number;
+}
+
+interface Uint32Array extends ArrayBufferView {
+ BYTES_PER_ELEMENT: number;
+ length: number;
+ [index: number]: number;
+ get(index: number): number;
+ set(index: number, value: number): void;
+ set(array: Uint32Array, offset?: number): void;
+ set(array: number[], offset?: number): void;
+ subarray(begin: number, end?: number): Uint32Array;
+}
+declare var Uint32Array: {
+ prototype: Uint32Array;
+ new (length: number): Uint32Array;
+ new (array: Uint32Array): Uint32Array;
+ new (array: number[]): Uint32Array;
+ new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint32Array;
+ BYTES_PER_ELEMENT: number;
+}
+
+interface Float32Array extends ArrayBufferView {
+ BYTES_PER_ELEMENT: number;
+ length: number;
+ [index: number]: number;
+ get(index: number): number;
+ set(index: number, value: number): void;
+ set(array: Float32Array, offset?: number): void;
+ set(array: number[], offset?: number): void;
+ subarray(begin: number, end?: number): Float32Array;
+}
+declare var Float32Array: {
+ prototype: Float32Array;
+ new (length: number): Float32Array;
+ new (array: Float32Array): Float32Array;
+ new (array: number[]): Float32Array;
+ new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Float32Array;
+ BYTES_PER_ELEMENT: number;
+}
+
+interface Float64Array extends ArrayBufferView {
+ BYTES_PER_ELEMENT: number;
+ length: number;
+ [index: number]: number;
+ get(index: number): number;
+ set(index: number, value: number): void;
+ set(array: Float64Array, offset?: number): void;
+ set(array: number[], offset?: number): void;
+ subarray(begin: number, end?: number): Float64Array;
+}
+declare var Float64Array: {
+ prototype: Float64Array;
+ new (length: number): Float64Array;
+ new (array: Float64Array): Float64Array;
+ new (array: number[]): Float64Array;
+ new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Float64Array;
+ BYTES_PER_ELEMENT: number;
+}
+
+interface DataView extends ArrayBufferView {
+ getInt8(byteOffset: number): number;
+ getUint8(byteOffset: number): number;
+ getInt16(byteOffset: number, littleEndian?: bool): number;
+ getUint16(byteOffset: number, littleEndian?: bool): number;
+ getInt32(byteOffset: number, littleEndian?: bool): number;
+ getUint32(byteOffset: number, littleEndian?: bool): number;
+ getFloat32(byteOffset: number, littleEndian?: bool): number;
+ getFloat64(byteOffset: number, littleEndian?: bool): number;
+
+ setInt8(byteOffset: number, value: number): void;
+ setUint8(byteOffset: number, value: number): void;
+ setInt16(byteOffset: number, value: number, littleEndian?: bool): void;
+ setUint16(byteOffset: number, value: number, littleEndian?: bool): void;
+ setInt32(byteOffset: number, value: number, littleEndian?: bool): void;
+ setUint32(byteOffset: number, value: number, littleEndian?: bool): void;
+ setFloat32(byteOffset: number, value: number, littleEndian?: bool): void;
+ setFloat64(byteOffset: number, value: number, littleEndian?: bool): void;
+}
+declare var DataView: {
+ prototype: DataView;
+ new (buffer: ArrayBuffer, byteOffset?: number, length?: number): DataView;
+}
+
+////////////////
+/// IE9 DOM APIs (note that
+////////////////
+
+interface NavigatorID {
+ appVersion: string;
+ appName: string;
+ userAgent: string;
+ platform: string;
+}
+
+interface HTMLTableElement extends HTMLElement, DOML2DeprecatedBorderStyle_HTMLTableElement, DOML2DeprecatedAlignmentStyle_HTMLTableElement, MSBorderColorStyle, MSDataBindingExtensions, MSHTMLTableElementExtensions, DOML2DeprecatedBackgroundStyle, MSBorderColorHighlightStyle, MSDataBindingTableExtensions, DOML2DeprecatedBackgroundColorStyle {
+ tBodies: HTMLCollection;
+ width: string;
+ tHead: HTMLTableSectionElement;
+ cellSpacing: string;
+ tFoot: HTMLTableSectionElement;
+ frame: string;
+ rows: HTMLCollection;
+ rules: string;
+ cellPadding: string;
+ summary: string;
+ caption: HTMLTableCaptionElement;
+ deleteRow(index?: number): void;
+ createTBody(): HTMLElement;
+ deleteCaption(): void;
+ insertRow(index?: number): HTMLElement;
+ deleteTFoot(): void;
+ createTHead(): HTMLElement;
+ deleteTHead(): void;
+ createCaption(): HTMLElement;
+ createTFoot(): HTMLElement;
+}
+declare var HTMLTableElement: {
+ prototype: HTMLTableElement;
+ new(): HTMLTableElement;
+}
+
+interface TreeWalker {
+ whatToShow: number;
+ filter: NodeFilterCallback;
+ root: Node;
+ currentNode: Node;
+ expandEntityReferences: bool;
+ previousSibling(): Node;
+ lastChild(): Node;
+ nextSibling(): Node;
+ nextNode(): Node;
+ parentNode(): Node;
+ firstChild(): Node;
+ previousNode(): Node;
+}
+declare var TreeWalker: {
+ prototype: TreeWalker;
+ new(): TreeWalker;
+}
+
+interface GetSVGDocument {
+ getSVGDocument(): SVGDocument;
+}
+
+interface HTMLHtmlElementDOML2Deprecated {
+ version: string;
+}
+
+interface SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {
+ y: number;
+ y1: number;
+ x: number;
+ x1: number;
+}
+declare var SVGPathSegCurvetoQuadraticRel: {
+ prototype: SVGPathSegCurvetoQuadraticRel;
+ new(): SVGPathSegCurvetoQuadraticRel;
+}
+
+interface Performance {
+ navigation: PerformanceNavigation;
+ timing: PerformanceTiming;
+ toJSON(): any;
+}
+declare var Performance: {
+ prototype: Performance;
+ new(): Performance;
+}
+
+interface SVGSVGElementEventHandlers {
+ onresize: (ev: UIEvent) => any;
+ onunload: (ev: Event) => any;
+ onscroll: (ev: UIEvent) => any;
+ onerror: (ev: Event) => any;
+ onzoom: (ev: any) => any;
+ onabort: (ev: UIEvent) => any;
+}
+
+interface MSDataBindingTableExtensions {
+ dataPageSize: number;
+ nextPage(): void;
+ firstPage(): void;
+ refresh(): void;
+ previousPage(): void;
+ lastPage(): void;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLParagraphElement {
+ align: string;
+}
+
+interface CompositionEvent extends UIEvent {
+ data: string;
+ locale: string;
+ initCompositionEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, dataArg: string, locale: string): void;
+}
+declare var CompositionEvent: {
+ prototype: CompositionEvent;
+ new(): CompositionEvent;
+}
+
+interface SVGMarkerElement extends SVGElement, SVGStylable, SVGLangSpace, SVGFitToViewBox {
+ orientType: SVGAnimatedEnumeration;
+ markerUnits: SVGAnimatedEnumeration;
+ markerWidth: SVGAnimatedLength;
+ markerHeight: SVGAnimatedLength;
+ orientAngle: SVGAnimatedAngle;
+ refY: SVGAnimatedLength;
+ refX: SVGAnimatedLength;
+ setOrientToAngle(angle: SVGAngle): void;
+ setOrientToAuto(): void;
+ SVG_MARKER_ORIENT_UNKNOWN: number;
+ SVG_MARKER_ORIENT_ANGLE: number;
+ SVG_MARKERUNITS_UNKNOWN: number;
+ SVG_MARKERUNITS_STROKEWIDTH: number;
+ SVG_MARKER_ORIENT_AUTO: number;
+ SVG_MARKERUNITS_USERSPACEONUSE: number;
+}
+declare var SVGMarkerElement: {
+ prototype: SVGMarkerElement;
+ new(): SVGMarkerElement;
+ SVG_MARKER_ORIENT_UNKNOWN: number;
+ SVG_MARKER_ORIENT_ANGLE: number;
+ SVG_MARKERUNITS_UNKNOWN: number;
+ SVG_MARKERUNITS_STROKEWIDTH: number;
+ SVG_MARKER_ORIENT_AUTO: number;
+ SVG_MARKERUNITS_USERSPACEONUSE: number;
+}
+
+interface WindowTimers {
+ clearTimeout(handle: number): void;
+ setTimeout(expression: any, msec?: number, language?: any): number;
+ clearInterval(handle: number): void;
+ setInterval(expression: any, msec?: number, language?: any): number;
+}
+
+interface CSSStyleDeclaration extends CSS3Properties, SVG1_1Properties, CSS2Properties {
+ cssText: string;
+ length: number;
+ parentRule: CSSRule;
+ getPropertyPriority(propertyName: string): string;
+ getPropertyValue(propertyName: string): string;
+ removeProperty(propertyName: string): string;
+ item(index: number): string;
+ [index: number]: string;
+ setProperty(propertyName: string, value: string, priority?: string): void;
+}
+declare var CSSStyleDeclaration: {
+ prototype: CSSStyleDeclaration;
+ new(): CSSStyleDeclaration;
+}
+
+interface SVGGElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests {
+}
+declare var SVGGElement: {
+ prototype: SVGGElement;
+ new(): SVGGElement;
+}
+
+interface MSStyleCSSProperties extends MSCSSProperties {
+ pixelWidth: number;
+ posHeight: number;
+ posLeft: number;
+ pixelTop: number;
+ pixelBottom: number;
+ textDecorationNone: bool;
+ pixelLeft: number;
+ posTop: number;
+ posBottom: number;
+ textDecorationOverline: bool;
+ posWidth: number;
+ textDecorationLineThrough: bool;
+ pixelHeight: number;
+ textDecorationBlink: bool;
+ posRight: number;
+ pixelRight: number;
+ textDecorationUnderline: bool;
+}
+declare var MSStyleCSSProperties: {
+ prototype: MSStyleCSSProperties;
+ new(): MSStyleCSSProperties;
+}
+
+interface MSCSSStyleSheetExtensions {
+ owningElement: Element;
+ imports: StyleSheetList;
+ isAlternate: bool;
+ rules: MSCSSRuleList;
+ isPrefAlternate: bool;
+ readOnly: bool;
+ cssText: string;
+ href: string;
+ id: string;
+ pages: StyleSheetPageList;
+ addImport(bstrURL: string, lIndex?: number): number;
+ addPageRule(bstrSelector: string, bstrStyle: string, lIndex?: number): number;
+ removeRule(lIndex: number): void;
+ addRule(bstrSelector: string, bstrStyle?: string, lIndex?: number): number;
+ removeImport(lIndex: number): void;
+}
+
+interface Navigator extends NavigatorID, NavigatorOnLine, NavigatorDoNotTrack, NavigatorAbilities, NavigatorGeolocation, MSNavigatorAbilities {
+}
+declare var Navigator: {
+ prototype: Navigator;
+ new(): Navigator;
+}
+
+interface SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg {
+ y: number;
+ x2: number;
+ x: number;
+ y2: number;
+}
+declare var SVGPathSegCurvetoCubicSmoothAbs: {
+ prototype: SVGPathSegCurvetoCubicSmoothAbs;
+ new(): SVGPathSegCurvetoCubicSmoothAbs;
+}
+
+interface MSBorderColorStyle_HTMLFrameSetElement {
+ borderColor: any;
+}
+
+interface SVGZoomEvent extends UIEvent {
+ zoomRectScreen: SVGRect;
+ previousScale: number;
+ newScale: number;
+ previousTranslate: SVGPoint;
+ newTranslate: SVGPoint;
+}
+declare var SVGZoomEvent: {
+ prototype: SVGZoomEvent;
+ new(): SVGZoomEvent;
+}
+
+interface NodeSelector {
+ querySelectorAll(selectors: string): NodeList;
+ querySelector(selectors: string): Element;
+}
+
+interface HTMLTableDataCellElement extends HTMLTableCellElement, MSHTMLTableDataCellElementExtensions {
+}
+declare var HTMLTableDataCellElement: {
+ prototype: HTMLTableDataCellElement;
+ new(): HTMLTableDataCellElement;
+}
+
+interface MSHTMLDirectoryElementExtensions extends DOML2DeprecatedListNumberingAndBulletStyle {
+}
+
+interface HTMLBaseElement extends HTMLElement {
+ target: string;
+ href: string;
+}
+declare var HTMLBaseElement: {
+ prototype: HTMLBaseElement;
+ new(): HTMLBaseElement;
+}
+
+interface ClientRect {
+ left: number;
+ width: number;
+ right: number;
+ top: number;
+ bottom: number;
+ height: number;
+}
+declare var ClientRect: {
+ prototype: ClientRect;
+ new(): ClientRect;
+}
+
+interface PositionErrorCallback {
+ (error: PositionError): void;
+}
+
+interface DOMImplementation extends DOMHTMLImplementation {
+ createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType;
+ createDocument(namespaceURI: string, qualifiedName: string, doctype: DocumentType): Document;
+ hasFeature(feature: string, version?: string): bool;
+}
+declare var DOMImplementation: {
+ prototype: DOMImplementation;
+ new(): DOMImplementation;
+}
+
+interface DOML2DeprecatedWidthStyle_HTMLBlockElement {
+ width: number;
+}
+
+interface SVGUnitTypes {
+ SVG_UNIT_TYPE_UNKNOWN: number;
+ SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
+ SVG_UNIT_TYPE_USERSPACEONUSE: number;
+}
+declare var SVGUnitTypes: {
+ prototype: SVGUnitTypes;
+ new(): SVGUnitTypes;
+ SVG_UNIT_TYPE_UNKNOWN: number;
+ SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number;
+ SVG_UNIT_TYPE_USERSPACEONUSE: number;
+}
+
+interface DocumentRange {
+ createRange(): Range;
+}
+
+interface MSHTMLDocumentExtensions {
+ onrowexit: (ev: MSEventObj) => any;
+ compatible: MSCompatibleInfoCollection;
+ oncontrolselect: (ev: MSEventObj) => any;
+ onrowsinserted: (ev: MSEventObj) => any;
+ onpropertychange: (ev: MSEventObj) => any;
+ media: string;
+ onafterupdate: (ev: MSEventObj) => any;
+ onhelp: (ev: Event) => any;
+ uniqueID: string;
+ onbeforeactivate: (ev: UIEvent) => any;
+ onstoragecommit: (ev: StorageEvent) => any;
+ onselectionchange: (ev: Event) => any;
+ documentMode: number;
+ onfocusout: (ev: FocusEvent) => any;
+ ondataavailable: (ev: MSEventObj) => any;
+ onbeforeupdate: (ev: MSEventObj) => any;
+ onfocusin: (ev: FocusEvent) => any;
+ security: string;
+ namespaces: MSNamespaceInfoCollection;
+ ondatasetcomplete: (ev: MSEventObj) => any;
+ onbeforedeactivate: (ev: UIEvent) => any;
+ onstop: (ev: Event) => any;
+ onactivate: (ev: UIEvent) => any;
+ onmssitemodejumplistitemremoved: (ev: MSSiteModeEvent) => any;
+ frames: Window;
+ onselectstart: (ev: Event) => any;
+ onerrorupdate: (ev: MSEventObj) => any;
+ parentWindow: Window;
+ ondeactivate: (ev: UIEvent) => any;
+ ondatasetchanged: (ev: MSEventObj) => any;
+ onrowsdelete: (ev: MSEventObj) => any;
+ onmsthumbnailclick: (ev: MSSiteModeEvent) => any;
+ onrowenter: (ev: MSEventObj) => any;
+ onbeforeeditfocus: (ev: MSEventObj) => any;
+ Script: MSScriptHost;
+ oncellchange: (ev: MSEventObj) => any;
+ URLUnencoded: string;
+ updateSettings(): void;
+ execCommandShowHelp(commandId: string): bool;
+ releaseCapture(): void;
+ focus(): void;
+}
+
+interface CSS2Properties {
+ backgroundAttachment: string;
+ visibility: string;
+ fontFamily: string;
+ borderRightStyle: string;
+ clear: string;
+ content: string;
+ counterIncrement: string;
+ orphans: string;
+ marginBottom: string;
+ borderStyle: string;
+ counterReset: string;
+ outlineWidth: string;
+ marginRight: string;
+ paddingLeft: string;
+ borderBottom: string;
+ marginTop: string;
+ borderTopColor: string;
+ top: string;
+ fontWeight: string;
+ textIndent: string;
+ borderRight: string;
+ width: string;
+ listStyleImage: string;
+ cursor: string;
+ listStylePosition: string;
+ borderTopStyle: string;
+ direction: string;
+ maxWidth: string;
+ color: string;
+ clip: string;
+ borderRightWidth: string;
+ verticalAlign: string;
+ pageBreakAfter: string;
+ overflow: string;
+ borderBottomStyle: string;
+ borderLeftStyle: string;
+ fontStretch: string;
+ emptyCells: string;
+ padding: string;
+ paddingRight: string;
+ background: string;
+ bottom: string;
+ height: string;
+ paddingTop: string;
+ right: string;
+ borderLeftWidth: string;
+ borderLeft: string;
+ backgroundPosition: string;
+ backgroundColor: string;
+ widows: string;
+ lineHeight: string;
+ pageBreakInside: string;
+ borderTopWidth: string;
+ left: string;
+ outlineStyle: string;
+ borderTop: string;
+ paddingBottom: string;
+ outlineColor: string;
+ wordSpacing: string;
+ outline: string;
+ font: string;
+ marginLeft: string;
+ display: string;
+ maxHeight: string;
+ cssFloat: string;
+ letterSpacing: string;
+ borderSpacing: string;
+ backgroundRepeat: string;
+ fontSizeAdjust: string;
+ borderLeftColor: string;
+ borderWidth: string;
+ backgroundImage: string;
+ listStyleType: string;
+ whiteSpace: string;
+ fontStyle: string;
+ borderBottomColor: string;
+ minWidth: string;
+ position: string;
+ zIndex: string;
+ borderColor: string;
+ listStyle: string;
+ captionSide: string;
+ borderCollapse: string;
+ fontVariant: string;
+ quotes: string;
+ tableLayout: string;
+ unicodeBidi: string;
+ borderBottomWidth: string;
+ minHeight: string;
+ textDecoration: string;
+ fontSize: string;
+ border: string;
+ pageBreakBefore: string;
+ textAlign: string;
+ textTransform: string;
+ margin: string;
+ borderRightColor: string;
+}
+
+interface MSImageResourceExtensions_HTMLInputElement {
+ dynsrc: string;
+ vrml: string;
+ lowsrc: string;
+ start: string;
+ loop: number;
+}
+
+interface MSHTMLEmbedElementExtensions {
+ palette: string;
+ hidden: string;
+ pluginspage: string;
+ units: string;
+}
+
+interface MSHTMLModElementExtensions {
+}
+
+interface Element extends Node, NodeSelector, ElementTraversal, MSElementExtensions {
+ scrollTop: number;
+ clientLeft: number;
+ scrollLeft: number;
+ tagName: string;
+ clientWidth: number;
+ scrollWidth: number;
+ clientHeight: number;
+ clientTop: number;
+ scrollHeight: number;
+ getAttribute(name?: string): string;
+ getElementsByTagNameNS(namespaceURI: string, localName: string): NodeList;
+ hasAttributeNS(namespaceURI: string, localName: string): bool;
+ getBoundingClientRect(): ClientRect;
+ getAttributeNS(namespaceURI: string, localName: string): string;
+ getAttributeNodeNS(namespaceURI: string, localName: string): Attr;
+ setAttributeNodeNS(newAttr: Attr): Attr;
+ hasAttribute(name: string): bool;
+ removeAttribute(name?: string): void;
+ setAttributeNS(namespaceURI: string, qualifiedName: string, value: string): void;
+ getAttributeNode(name: string): Attr;
+ getElementsByTagName(name: string): NodeList;
+ setAttributeNode(newAttr: Attr): Attr;
+ getClientRects(): ClientRectList;
+ removeAttributeNode(oldAttr: Attr): Attr;
+ setAttribute(name?: string, value?: string): void;
+ removeAttributeNS(namespaceURI: string, localName: string): void;
+}
+declare var Element: {
+ prototype: Element;
+ new(): Element;
+}
+
+interface SVGDocument {
+ rootElement: SVGSVGElement;
+}
+
+interface HTMLNextIdElement extends HTMLElement {
+ n: string;
+}
+declare var HTMLNextIdElement: {
+ prototype: HTMLNextIdElement;
+ new(): HTMLNextIdElement;
+}
+
+interface SVGPathSegMovetoRel extends SVGPathSeg {
+ y: number;
+ x: number;
+}
+declare var SVGPathSegMovetoRel: {
+ prototype: SVGPathSegMovetoRel;
+ new(): SVGPathSegMovetoRel;
+}
+
+interface SVGLineElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests {
+ y1: SVGAnimatedLength;
+ x2: SVGAnimatedLength;
+ x1: SVGAnimatedLength;
+ y2: SVGAnimatedLength;
+}
+declare var SVGLineElement: {
+ prototype: SVGLineElement;
+ new(): SVGLineElement;
+}
+
+interface HTMLParagraphElement extends HTMLElement, DOML2DeprecatedAlignmentStyle_HTMLParagraphElement, MSHTMLParagraphElementExtensions {
+}
+declare var HTMLParagraphElement: {
+ prototype: HTMLParagraphElement;
+ new(): HTMLParagraphElement;
+}
+
+interface MSHTMLTextAreaElementExtensions {
+ status: any;
+ createTextRange(): TextRange;
+}
+
+interface ErrorFunction {
+ (eventOrMessage: any, source: string, fileno: number): any;
+}
+
+interface HTMLAreasCollection extends HTMLCollection {
+ remove(index?: number): void;
+ add(element: HTMLElement, before?: any): void;
+}
+declare var HTMLAreasCollection: {
+ prototype: HTMLAreasCollection;
+ new(): HTMLAreasCollection;
+}
+
+interface SVGDescElement extends SVGElement, SVGStylable, SVGLangSpace {
+}
+declare var SVGDescElement: {
+ prototype: SVGDescElement;
+ new(): SVGDescElement;
+}
+
+interface Node extends EventTarget {
+ nodeType: number;
+ previousSibling: Node;
+ localName: string;
+ namespaceURI: string;
+ textContent: string;
+ parentNode: Node;
+ nextSibling: Node;
+ nodeValue: string;
+ lastChild: Node;
+ childNodes: NodeList;
+ nodeName: string;
+ ownerDocument: Document;
+ attributes: Attr[];
+ firstChild: Node;
+ prefix: string;
+ removeChild(oldChild: Node): Node;
+ appendChild(newChild: Node): Node;
+ isSupported(feature: string, version: string): bool;
+ isEqualNode(arg: Node): bool;
+ lookupPrefix(namespaceURI: string): string;
+ isDefaultNamespace(namespaceURI: string): bool;
+ compareDocumentPosition(other: Node): number;
+ normalize(): void;
+ isSameNode(other: Node): bool;
+ hasAttributes(): bool;
+ lookupNamespaceURI(prefix: string): string;
+ cloneNode(deep?: bool): Node;
+ hasChildNodes(): bool;
+ replaceChild(newChild: Node, oldChild: Node): Node;
+ insertBefore(newChild: Node, refChild?: Node): Node;
+ ENTITY_REFERENCE_NODE: number;
+ ATTRIBUTE_NODE: number;
+ DOCUMENT_FRAGMENT_NODE: number;
+ TEXT_NODE: number;
+ ELEMENT_NODE: number;
+ COMMENT_NODE: number;
+ DOCUMENT_POSITION_DISCONNECTED: number;
+ DOCUMENT_POSITION_CONTAINED_BY: number;
+ DOCUMENT_POSITION_CONTAINS: number;
+ DOCUMENT_TYPE_NODE: number;
+ DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
+ DOCUMENT_NODE: number;
+ ENTITY_NODE: number;
+ PROCESSING_INSTRUCTION_NODE: number;
+ CDATA_SECTION_NODE: number;
+ NOTATION_NODE: number;
+ DOCUMENT_POSITION_FOLLOWING: number;
+ DOCUMENT_POSITION_PRECEDING: number;
+}
+declare var Node: {
+ prototype: Node;
+ new(): Node;
+ ENTITY_REFERENCE_NODE: number;
+ ATTRIBUTE_NODE: number;
+ DOCUMENT_FRAGMENT_NODE: number;
+ TEXT_NODE: number;
+ ELEMENT_NODE: number;
+ COMMENT_NODE: number;
+ DOCUMENT_POSITION_DISCONNECTED: number;
+ DOCUMENT_POSITION_CONTAINED_BY: number;
+ DOCUMENT_POSITION_CONTAINS: number;
+ DOCUMENT_TYPE_NODE: number;
+ DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
+ DOCUMENT_NODE: number;
+ ENTITY_NODE: number;
+ PROCESSING_INSTRUCTION_NODE: number;
+ CDATA_SECTION_NODE: number;
+ NOTATION_NODE: number;
+ DOCUMENT_POSITION_FOLLOWING: number;
+ DOCUMENT_POSITION_PRECEDING: number;
+}
+
+interface MSHTMLLegendElementExtensions {
+}
+
+interface MSCSSStyleDeclarationExtensions {
+ getAttribute(attributeName: string, flags?: number): any;
+ setAttribute(attributeName: string, AttributeValue: any, flags?: number): void;
+ removeAttribute(attributeName: string, flags?: number): bool;
+}
+
+interface SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {
+ y: number;
+ x: number;
+}
+declare var SVGPathSegCurvetoQuadraticSmoothRel: {
+ prototype: SVGPathSegCurvetoQuadraticSmoothRel;
+ new(): SVGPathSegCurvetoQuadraticSmoothRel;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLTableRowElement {
+ align: string;
+}
+
+interface DOML2DeprecatedBorderStyle_HTMLObjectElement {
+ border: string;
+}
+
+interface MSHTMLSpanElementExtensions {
+}
+
+interface MSHTMLObjectElementExtensions {
+ object: Object;
+ alt: string;
+ classid: string;
+ altHtml: string;
+ BaseHref: string;
+}
+
+interface DOML2DeprecatedListSpaceReduction {
+ compact: bool;
+}
+
+interface CSS3Properties {
+ textAlignLast: string;
+ textUnderlinePosition: string;
+ wordWrap: string;
+ borderTopLeftRadius: string;
+ backgroundClip: string;
+ msTransformOrigin: string;
+ opacity: string;
+ overflowY: string;
+ boxShadow: string;
+ backgroundSize: string;
+ wordBreak: string;
+ boxSizing: string;
+ rubyOverhang: string;
+ rubyAlign: string;
+ textJustify: string;
+ borderRadius: string;
+ overflowX: string;
+ borderTopRightRadius: string;
+ msTransform: string;
+ borderBottomLeftRadius: string;
+ rubyPosition: string;
+ borderBottomRightRadius: string;
+ backgroundOrigin: string;
+ textOverflow: string;
+}
+
+interface MSScriptHost {
+}
+declare var MSScriptHost: {
+ prototype: MSScriptHost;
+ new(): MSScriptHost;
+}
+
+interface SVGClipPathElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests {
+ clipPathUnits: SVGAnimatedEnumeration;
+}
+declare var SVGClipPathElement: {
+ prototype: SVGClipPathElement;
+ new(): SVGClipPathElement;
+}
+
+interface MouseEvent extends UIEvent, MSMouseEventExtensions {
+ pageX: number;
+ offsetY: number;
+ x: number;
+ y: number;
+ altKey: bool;
+ metaKey: bool;
+ ctrlKey: bool;
+ offsetX: number;
+ screenX: number;
+ clientY: number;
+ shiftKey: bool;
+ screenY: number;
+ relatedTarget: EventTarget;
+ button: number;
+ pageY: number;
+ buttons: number;
+ clientX: number;
+ initMouseEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: bool, altKeyArg: bool, shiftKeyArg: bool, metaKeyArg: bool, buttonArg: number, relatedTargetArg: EventTarget): void;
+ getModifierState(keyArg: string): bool;
+}
+declare var MouseEvent: {
+ prototype: MouseEvent;
+ new(): MouseEvent;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLTableElement {
+ align: string;
+}
+
+interface RangeException {
+ code: number;
+ message: string;
+ toString(): string;
+ INVALID_NODE_TYPE_ERR: number;
+ BAD_BOUNDARYPOINTS_ERR: number;
+}
+declare var RangeException: {
+ prototype: RangeException;
+ new(): RangeException;
+ INVALID_NODE_TYPE_ERR: number;
+ BAD_BOUNDARYPOINTS_ERR: number;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLHRElement {
+ align: string;
+}
+
+interface SVGTextPositioningElement extends SVGTextContentElement {
+ y: SVGAnimatedLengthList;
+ rotate: SVGAnimatedNumberList;
+ dy: SVGAnimatedLengthList;
+ x: SVGAnimatedLengthList;
+ dx: SVGAnimatedLengthList;
+}
+declare var SVGTextPositioningElement: {
+ prototype: SVGTextPositioningElement;
+ new(): SVGTextPositioningElement;
+}
+
+interface HTMLAppletElement extends HTMLElement, DOML2DeprecatedWidthStyle_HTMLAppletElement, DOML2DeprecatedMarginStyle_HTMLObjectElement, MSHTMLAppletElementExtensions, MSDataBindingExtensions, MSDataBindingRecordSetExtensions, DOML2DeprecatedAlignmentStyle_HTMLObjectElement {
+ object: string;
+ archive: string;
+ codeBase: string;
+ alt: string;
+ name: string;
+ height: string;
+ code: string;
+}
+declare var HTMLAppletElement: {
+ prototype: HTMLAppletElement;
+ new(): HTMLAppletElement;
+}
+
+interface MSHTMLFieldSetElementExtensions extends DOML2DeprecatedAlignmentStyle_HTMLFieldSetElement {
+}
+
+interface DocumentEvent {
+ createEvent(eventInterface: string): Event;
+}
+
+interface MSHTMLUnknownElementExtensions {
+}
+
+interface TextMetrics {
+ width: number;
+}
+declare var TextMetrics: {
+ prototype: TextMetrics;
+ new(): TextMetrics;
+}
+
+interface DOML2DeprecatedWordWrapSuppression_HTMLBodyElement {
+ noWrap: bool;
+}
+
+interface HTMLOListElement extends HTMLElement, DOML2DeprecatedListNumberingAndBulletStyle, DOML2DeprecatedListSpaceReduction, MSHTMLOListElementExtensions {
+ start: number;
+}
+declare var HTMLOListElement: {
+ prototype: HTMLOListElement;
+ new(): HTMLOListElement;
+}
+
+interface MSHTMLTableCaptionElementExtensions {
+ vAlign: string;
+}
+
+interface SVGAnimatedString {
+ animVal: string;
+ baseVal: string;
+}
+declare var SVGAnimatedString: {
+ prototype: SVGAnimatedString;
+ new(): SVGAnimatedString;
+}
+
+interface SVGPathSegLinetoVerticalRel extends SVGPathSeg {
+ y: number;
+}
+declare var SVGPathSegLinetoVerticalRel: {
+ prototype: SVGPathSegLinetoVerticalRel;
+ new(): SVGPathSegLinetoVerticalRel;
+}
+
+interface CDATASection extends Text {
+}
+declare var CDATASection: {
+ prototype: CDATASection;
+ new(): CDATASection;
+}
+
+interface StyleMedia {
+ type: string;
+ matchMedium(mediaquery: string): bool;
+}
+declare var StyleMedia: {
+ prototype: StyleMedia;
+ new(): StyleMedia;
+}
+
+interface TextRange {
+ boundingLeft: number;
+ htmlText: string;
+ offsetLeft: number;
+ boundingWidth: number;
+ boundingHeight: number;
+ boundingTop: number;
+ text: string;
+ offsetTop: number;
+ moveToPoint(x: number, y: number): void;
+ queryCommandValue(cmdID: string): any;
+ getBookmark(): string;
+ move(Unit: string, Count?: number): number;
+ queryCommandIndeterm(cmdID: string): bool;
+ scrollIntoView(fStart?: bool): void;
+ findText(string: string, count?: number, flags?: number): bool;
+ execCommand(cmdID: string, showUI?: bool, value?: any): bool;
+ getBoundingClientRect(): ClientRect;
+ moveToBookmark(Bookmark: string): bool;
+ isEqual(range: TextRange): bool;
+ duplicate(): TextRange;
+ collapse(Start?: bool): void;
+ queryCommandText(cmdID: string): string;
+ select(): void;
+ pasteHTML(html: string): void;
+ inRange(range: TextRange): bool;
+ moveEnd(Unit: string, Count?: number): number;
+ getClientRects(): ClientRectList;
+ moveStart(Unit: string, Count?: number): number;
+ parentElement(): Element;
+ queryCommandState(cmdID: string): bool;
+ compareEndPoints(how: string, sourceRange: TextRange): number;
+ execCommandShowHelp(cmdID: string): bool;
+ moveToElementText(element: Element): void;
+ expand(Unit: string): bool;
+ queryCommandSupported(cmdID: string): bool;
+ setEndPoint(how: string, SourceRange: TextRange): void;
+ queryCommandEnabled(cmdID: string): bool;
+}
+declare var TextRange: {
+ prototype: TextRange;
+ new(): TextRange;
+}
+
+interface HTMLSelectElement extends HTMLElement, MSHTMLCollectionExtensions, MSDataBindingExtensions, MSHTMLSelectElementExtensions {
+ options: HTMLSelectElement;
+ value: string;
+ form: HTMLFormElement;
+ name: string;
+ size: number;
+ length: number;
+ selectedIndex: number;
+ multiple: bool;
+ type: string;
+ remove(index?: number): void;
+ add(element: HTMLElement, before?: any): void;
+ item(name?: any, index?: any): any;
+ (name: any, index: any): any;
+ namedItem(name: string): any;
+ [name: string]: any;
+ (name: string): any;
+}
+declare var HTMLSelectElement: {
+ prototype: HTMLSelectElement;
+ new(): HTMLSelectElement;
+}
+
+interface CSSStyleSheet extends StyleSheet, MSCSSStyleSheetExtensions {
+ ownerRule: CSSRule;
+ cssRules: CSSRuleList;
+ insertRule(rule: string, index?: number): number;
+ deleteRule(index?: number): void;
+}
+declare var CSSStyleSheet: {
+ prototype: CSSStyleSheet;
+ new(): CSSStyleSheet;
+}
+
+interface HTMLBlockElement extends HTMLElement, DOML2DeprecatedTextFlowControl_HTMLBlockElement, DOML2DeprecatedWidthStyle_HTMLBlockElement {
+ cite: string;
+}
+declare var HTMLBlockElement: {
+ prototype: HTMLBlockElement;
+ new(): HTMLBlockElement;
+}
+
+interface SVGTests {
+ requiredFeatures: SVGStringList;
+ requiredExtensions: SVGStringList;
+ systemLanguage: SVGStringList;
+ hasExtension(extension: string): bool;
+}
+
+interface MSSelection {
+ type: string;
+ typeDetail: string;
+ createRange(): TextRange;
+ clear(): void;
+ createRangeCollection(): TextRangeCollection;
+ empty(): void;
+}
+declare var MSSelection: {
+ prototype: MSSelection;
+ new(): MSSelection;
+}
+
+interface MSHTMLDListElementExtensions {
+}
+
+interface HTMLMetaElement extends HTMLElement, MSHTMLMetaElementExtensions {
+ httpEquiv: string;
+ name: string;
+ content: string;
+ scheme: string;
+}
+declare var HTMLMetaElement: {
+ prototype: HTMLMetaElement;
+ new(): HTMLMetaElement;
+}
+
+interface Selection {
+ isCollapsed: bool;
+ anchorNode: Node;
+ focusNode: Node;
+ anchorOffset: number;
+ focusOffset: number;
+ rangeCount: number;
+ addRange(range: Range): void;
+ collapseToEnd(): void;
+ toString(): string;
+ selectAllChildren(parentNode: Node): void;
+ getRangeAt(index: number): Range;
+ collapse(parentNode: Node, offset: number): void;
+ removeAllRanges(): void;
+ collapseToStart(): void;
+ deleteFromDocument(): void;
+ removeRange(range: Range): void;
+}
+declare var Selection: {
+ prototype: Selection;
+ new(): Selection;
+}
+
+interface SVGAnimatedAngle {
+ animVal: SVGAngle;
+ baseVal: SVGAngle;
+}
+declare var SVGAnimatedAngle: {
+ prototype: SVGAnimatedAngle;
+ new(): SVGAnimatedAngle;
+}
+
+interface SVGPatternElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGLangSpace, SVGTests, SVGFitToViewBox, SVGURIReference {
+ patternUnits: SVGAnimatedEnumeration;
+ y: SVGAnimatedLength;
+ width: SVGAnimatedLength;
+ x: SVGAnimatedLength;
+ patternContentUnits: SVGAnimatedEnumeration;
+ patternTransform: SVGAnimatedTransformList;
+ height: SVGAnimatedLength;
+}
+declare var SVGPatternElement: {
+ prototype: SVGPatternElement;
+ new(): SVGPatternElement;
+}
+
+interface SVGScriptElement extends SVGElement, SVGURIReference {
+ type: string;
+}
+declare var SVGScriptElement: {
+ prototype: SVGScriptElement;
+ new(): SVGScriptElement;
+}
+
+interface HTMLDDElement extends HTMLElement, DOML2DeprecatedWordWrapSuppression_HTMLDDElement {
+}
+declare var HTMLDDElement: {
+ prototype: HTMLDDElement;
+ new(): HTMLDDElement;
+}
+
+interface NodeIterator {
+ whatToShow: number;
+ filter: NodeFilterCallback;
+ root: Node;
+ expandEntityReferences: bool;
+ nextNode(): Node;
+ detach(): void;
+ previousNode(): Node;
+}
+declare var NodeIterator: {
+ prototype: NodeIterator;
+ new(): NodeIterator;
+}
+
+interface CSSStyleRule extends CSSRule, MSCSSStyleRuleExtensions {
+ selectorText: string;
+ style: MSStyleCSSProperties;
+}
+declare var CSSStyleRule: {
+ prototype: CSSStyleRule;
+ new(): CSSStyleRule;
+}
+
+interface MSDataBindingRecordSetReadonlyExtensions {
+ recordset: Object;
+ namedRecordset(dataMember: string, hierarchy?: any): Object;
+}
+
+interface HTMLLinkElement extends HTMLElement, MSLinkStyleExtensions, LinkStyle {
+ rel: string;
+ target: string;
+ href: string;
+ media: string;
+ rev: string;
+ type: string;
+ charset: string;
+ hreflang: string;
+}
+declare var HTMLLinkElement: {
+ prototype: HTMLLinkElement;
+ new(): HTMLLinkElement;
+}
+
+interface SVGViewElement extends SVGElement, SVGZoomAndPan, SVGFitToViewBox {
+ viewTarget: SVGStringList;
+}
+declare var SVGViewElement: {
+ prototype: SVGViewElement;
+ new(): SVGViewElement;
+}
+
+interface MSHTMLAppletElementExtensions extends DOML2DeprecatedBorderStyle_HTMLObjectElement {
+ codeType: string;
+ standby: string;
+ classid: string;
+ useMap: string;
+ form: HTMLFormElement;
+ data: string;
+ contentDocument: Document;
+ altHtml: string;
+ declare: bool;
+ type: string;
+ BaseHref: string;
+}
+
+interface SVGLocatable {
+ farthestViewportElement: SVGElement;
+ nearestViewportElement: SVGElement;
+ getBBox(): SVGRect;
+ getTransformToElement(element: SVGElement): SVGMatrix;
+ getCTM(): SVGMatrix;
+ getScreenCTM(): SVGMatrix;
+}
+
+interface HTMLFontElement extends HTMLElement, DOML2DeprecatedColorProperty, MSHTMLFontElementExtensions, DOML2DeprecatedSizeProperty {
+ face: string;
+}
+declare var HTMLFontElement: {
+ prototype: HTMLFontElement;
+ new(): HTMLFontElement;
+}
+
+interface MSHTMLTableElementExtensions {
+ cells: HTMLCollection;
+ height: any;
+ cols: number;
+ moveRow(indexFrom?: number, indexTo?: number): Object;
+}
+
+interface SVGTitleElement extends SVGElement, SVGStylable, SVGLangSpace {
+}
+declare var SVGTitleElement: {
+ prototype: SVGTitleElement;
+ new(): SVGTitleElement;
+}
+
+interface ControlRangeCollection {
+ length: number;
+ queryCommandValue(cmdID: string): any;
+ remove(index: number): void;
+ add(item: Element): void;
+ queryCommandIndeterm(cmdID: string): bool;
+ scrollIntoView(varargStart?: any): void;
+ item(index: number): Element;
+ [index: number]: Element;
+ execCommand(cmdID: string, showUI?: bool, value?: any): bool;
+ addElement(item: Element): void;
+ queryCommandState(cmdID: string): bool;
+ queryCommandSupported(cmdID: string): bool;
+ queryCommandEnabled(cmdID: string): bool;
+ queryCommandText(cmdID: string): string;
+ select(): void;
+}
+declare var ControlRangeCollection: {
+ prototype: ControlRangeCollection;
+ new(): ControlRangeCollection;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLImageElement {
+ align: string;
+}
+
+interface MSHTMLFrameElementExtensions {
+ width: any;
+ contentWindow: Window;
+ onload: (ev: Event) => any;
+ frameBorder: string;
+ height: any;
+ border: string;
+ frameSpacing: any;
+}
+
+interface MSNamespaceInfo extends MSEventAttachmentTarget {
+ urn: string;
+ onreadystatechange: (ev: Event) => any;
+ name: string;
+ readyState: string;
+ doImport(implementationUrl: string): void;
+}
+declare var MSNamespaceInfo: {
+ prototype: MSNamespaceInfo;
+ new(): MSNamespaceInfo;
+}
+
+interface WindowSessionStorage {
+ sessionStorage: Storage;
+}
+
+interface SVGAnimatedTransformList {
+ animVal: SVGTransformList;
+ baseVal: SVGTransformList;
+}
+declare var SVGAnimatedTransformList: {
+ prototype: SVGAnimatedTransformList;
+ new(): SVGAnimatedTransformList;
+}
+
+interface HTMLTableCaptionElement extends HTMLElement, MSHTMLTableCaptionElementExtensions, DOML2DeprecatedAlignmentStyle_HTMLTableCaptionElement {
+}
+declare var HTMLTableCaptionElement: {
+ prototype: HTMLTableCaptionElement;
+ new(): HTMLTableCaptionElement;
+}
+
+interface HTMLOptionElement extends HTMLElement, MSDataBindingExtensions {
+ index: number;
+ defaultSelected: bool;
+ value: string;
+ text: string;
+ form: HTMLFormElement;
+ label: string;
+ selected: bool;
+}
+declare var HTMLOptionElement: {
+ prototype: HTMLOptionElement;
+ new(): HTMLOptionElement;
+}
+
+interface HTMLMapElement extends HTMLElement {
+ name: string;
+ areas: HTMLAreasCollection;
+}
+declare var HTMLMapElement: {
+ prototype: HTMLMapElement;
+ new(): HTMLMapElement;
+}
+
+interface HTMLMenuElement extends HTMLElement, DOML2DeprecatedListSpaceReduction, MSHTMLMenuElementExtensions {
+ type: string;
+}
+declare var HTMLMenuElement: {
+ prototype: HTMLMenuElement;
+ new(): HTMLMenuElement;
+}
+
+interface MouseWheelEvent extends MouseEvent {
+ wheelDelta: number;
+ initMouseWheelEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, wheelDeltaArg: number): void;
+}
+declare var MouseWheelEvent: {
+ prototype: MouseWheelEvent;
+ new(): MouseWheelEvent;
+}
+
+interface SVGFitToViewBox {
+ viewBox: SVGAnimatedRect;
+ preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
+}
+
+interface MSHTMLAnchorElementExtensions {
+ nameProp: string;
+ protocolLong: string;
+ urn: string;
+ mimeType: string;
+ Methods: string;
+}
+
+interface SVGPointList {
+ numberOfItems: number;
+ replaceItem(newItem: SVGPoint, index: number): SVGPoint;
+ getItem(index: number): SVGPoint;
+ clear(): void;
+ appendItem(newItem: SVGPoint): SVGPoint;
+ initialize(newItem: SVGPoint): SVGPoint;
+ removeItem(index: number): SVGPoint;
+ insertItemBefore(newItem: SVGPoint, index: number): SVGPoint;
+}
+declare var SVGPointList: {
+ prototype: SVGPointList;
+ new(): SVGPointList;
+}
+
+interface MSElementCSSInlineStyleExtensions {
+ doScroll(component?: any): void;
+ componentFromPoint(x: number, y: number): string;
+}
+
+interface SVGAnimatedLengthList {
+ animVal: SVGLengthList;
+ baseVal: SVGLengthList;
+}
+declare var SVGAnimatedLengthList: {
+ prototype: SVGAnimatedLengthList;
+ new(): SVGAnimatedLengthList;
+}
+
+interface MSHTMLTableDataCellElementExtensions {
+}
+
+interface Window extends ViewCSS, MSEventAttachmentTarget, MSWindowExtensions, WindowPerformance, ScreenView, EventTarget, WindowLocalStorage, WindowSessionStorage, WindowTimers {
+ ondragend: (ev: DragEvent) => any;
+ onkeydown: (ev: KeyboardEvent) => any;
+ ondragover: (ev: DragEvent) => any;
+ onkeyup: (ev: KeyboardEvent) => any;
+ onreset: (ev: Event) => any;
+ onmouseup: (ev: MouseEvent) => any;
+ ondragstart: (ev: DragEvent) => any;
+ ondrag: (ev: DragEvent) => any;
+ onmouseover: (ev: MouseEvent) => any;
+ ondragleave: (ev: DragEvent) => any;
+ history: History;
+ name: string;
+ onafterprint: (ev: Event) => any;
+ onpause: (ev: Event) => any;
+ onbeforeprint: (ev: Event) => any;
+ top: Window;
+ onmousedown: (ev: MouseEvent) => any;
+ onseeked: (ev: Event) => any;
+ opener: Window;
+ onclick: (ev: MouseEvent) => any;
+ onwaiting: (ev: Event) => any;
+ ononline: (ev: Event) => any;
+ ondurationchange: (ev: Event) => any;
+ frames: Window;
+ onblur: (ev: FocusEvent) => any;
+ onemptied: (ev: Event) => any;
+ onseeking: (ev: Event) => any;
+ oncanplay: (ev: Event) => any;
+ onstalled: (ev: Event) => any;
+ onmousemove: (ev: MouseEvent) => any;
+ onoffline: (ev: Event) => any;
+ length: number;
+ onbeforeunload: (ev: BeforeUnloadEvent) => any;
+ onratechange: (ev: Event) => any;
+ onstorage: (ev: StorageEvent) => any;
+ onloadstart: (ev: Event) => any;
+ ondragenter: (ev: DragEvent) => any;
+ onsubmit: (ev: Event) => any;
+ self: Window;
+ onprogress: (ev: any) => any;
+ ondblclick: (ev: MouseEvent) => any;
+ oncontextmenu: (ev: MouseEvent) => any;
+ onchange: (ev: Event) => any;
+ onloadedmetadata: (ev: Event) => any;
+ onplay: (ev: Event) => any;
+ onerror: ErrorFunction;
+ onplaying: (ev: Event) => any;
+ parent: Window;
+ location: Location;
+ oncanplaythrough: (ev: Event) => any;
+ onabort: (ev: UIEvent) => any;
+ onreadystatechange: (ev: Event) => any;
+ onkeypress: (ev: KeyboardEvent) => any;
+ frameElement: Element;
+ onloadeddata: (ev: Event) => any;
+ onsuspend: (ev: Event) => any;
+ window: Window;
+ onfocus: (ev: FocusEvent) => any;
+ onmessage: (ev: MessageEvent) => any;
+ ontimeupdate: (ev: Event) => any;
+ onresize: (ev: UIEvent) => any;
+ navigator: Navigator;
+ onselect: (ev: UIEvent) => any;
+ ondrop: (ev: DragEvent) => any;
+ onmouseout: (ev: MouseEvent) => any;
+ onended: (ev: Event) => any;
+ onhashchange: (ev: Event) => any;
+ onunload: (ev: Event) => any;
+ onscroll: (ev: UIEvent) => any;
+ onmousewheel: (ev: MouseWheelEvent) => any;
+ onload: (ev: Event) => any;
+ onvolumechange: (ev: Event) => any;
+ oninput: (ev: Event) => any;
+ alert(message?: string): void;
+ focus(): void;
+ print(): void;
+ prompt(message?: string, defaul?: string): string;
+ toString(): string;
+ open(url?: string, target?: string, features?: string, replace?: bool): Window;
+ close(): void;
+ confirm(message?: string): bool;
+ postMessage(message: any, targetOrigin: string, ports?: any): void;
+ showModalDialog(url?: string, argument?: any, options?: any): any;
+ blur(): void;
+ getSelection(): Selection;
+}
+declare var Window: {
+ prototype: Window;
+ new(): Window;
+}
+
+interface SVGAnimatedPreserveAspectRatio {
+ animVal: SVGPreserveAspectRatio;
+ baseVal: SVGPreserveAspectRatio;
+}
+declare var SVGAnimatedPreserveAspectRatio: {
+ prototype: SVGAnimatedPreserveAspectRatio;
+ new(): SVGAnimatedPreserveAspectRatio;
+}
+
+interface MSSiteModeEvent extends Event {
+ buttonID: number;
+ actionURL: string;
+}
+declare var MSSiteModeEvent: {
+ prototype: MSSiteModeEvent;
+ new(): MSSiteModeEvent;
+}
+
+interface MSCSSStyleRuleExtensions {
+ readOnly: bool;
+}
+
+interface StyleSheetPageList {
+ length: number;
+ item(index: number): StyleSheetPage;
+ [index: number]: StyleSheetPage;
+}
+declare var StyleSheetPageList: {
+ prototype: StyleSheetPageList;
+ new(): StyleSheetPageList;
+}
+
+interface HTMLCollection extends MSHTMLCollectionExtensions {
+ length: number;
+ item(nameOrIndex?: any, optionalIndex?: any): Element;
+ (nameOrIndex: any, optionalIndex: any): Element;
+ namedItem(name: string): Element;
+ [index: number]: Element;
+ [name: string]: Element;
+ (name: string): Element;
+}
+declare var HTMLCollection: {
+ prototype: HTMLCollection;
+ new(): HTMLCollection;
+}
+
+interface MSCSSProperties extends CSSStyleDeclaration, MSCSSStyleDeclarationExtensions {
+ scrollbarShadowColor: string;
+ scrollbarHighlightColor: string;
+ layoutGridChar: string;
+ layoutGridType: string;
+ textAutospace: string;
+ textKashidaSpace: string;
+ writingMode: string;
+ scrollbarFaceColor: string;
+ backgroundPositionY: string;
+ lineBreak: string;
+ imeMode: string;
+ msBlockProgression: string;
+ layoutGridLine: string;
+ scrollbarBaseColor: string;
+ layoutGrid: string;
+ layoutFlow: string;
+ textKashida: string;
+ filter: string;
+ zoom: string;
+ scrollbarArrowColor: string;
+ behavior: string;
+ backgroundPositionX: string;
+ accelerator: string;
+ layoutGridMode: string;
+ textJustifyTrim: string;
+ scrollbar3dLightColor: string;
+ msInterpolationMode: string;
+ scrollbarTrackColor: string;
+ scrollbarDarkShadowColor: string;
+ styleFloat: string;
+}
+declare var MSCSSProperties: {
+ prototype: MSCSSProperties;
+ new(): MSCSSProperties;
+}
+
+interface HTMLImageElement extends HTMLElement, DOML2DeprecatedMarginStyle, DOML2DeprecatedBorderStyle, DOML2DeprecatedAlignmentStyle_HTMLImageElement, MSImageResourceExtensions, MSHTMLImageElementExtensions, MSDataBindingExtensions, MSResourceMetadata {
+ width: number;
+ naturalHeight: number;
+ alt: string;
+ src: string;
+ useMap: string;
+ naturalWidth: number;
+ name: string;
+ height: number;
+ longDesc: string;
+ isMap: bool;
+ complete: bool;
+}
+declare var HTMLImageElement: {
+ prototype: HTMLImageElement;
+ new(): HTMLImageElement;
+}
+
+interface HTMLAreaElement extends HTMLElement, MSHTMLAreaElementExtensions {
+ protocol: string;
+ search: string;
+ alt: string;
+ coords: string;
+ hostname: string;
+ port: string;
+ pathname: string;
+ host: string;
+ hash: string;
+ target: string;
+ href: string;
+ noHref: bool;
+ shape: string;
+ toString(): string;
+}
+declare var HTMLAreaElement: {
+ prototype: HTMLAreaElement;
+ new(): HTMLAreaElement;
+}
+
+interface EventTarget {
+ removeEventListener(type: string, listener: EventListener, useCapture?: bool): void;
+ addEventListener(type: string, listener: EventListener, useCapture?: bool): void;
+ dispatchEvent(evt: Event): bool;
+}
+
+interface SVGAngle {
+ valueAsString: string;
+ valueInSpecifiedUnits: number;
+ value: number;
+ unitType: number;
+ newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
+ convertToSpecifiedUnits(unitType: number): void;
+ SVG_ANGLETYPE_RAD: number;
+ SVG_ANGLETYPE_UNKNOWN: number;
+ SVG_ANGLETYPE_UNSPECIFIED: number;
+ SVG_ANGLETYPE_DEG: number;
+ SVG_ANGLETYPE_GRAD: number;
+}
+declare var SVGAngle: {
+ prototype: SVGAngle;
+ new(): SVGAngle;
+ SVG_ANGLETYPE_RAD: number;
+ SVG_ANGLETYPE_UNKNOWN: number;
+ SVG_ANGLETYPE_UNSPECIFIED: number;
+ SVG_ANGLETYPE_DEG: number;
+ SVG_ANGLETYPE_GRAD: number;
+}
+
+interface HTMLButtonElement extends HTMLElement, MSHTMLButtonElementExtensions, MSDataBindingExtensions {
+ value: string;
+ form: HTMLFormElement;
+ name: string;
+ type: string;
+}
+declare var HTMLButtonElement: {
+ prototype: HTMLButtonElement;
+ new(): HTMLButtonElement;
+}
+
+interface MSHTMLLabelElementExtensions {
+}
+
+interface HTMLSourceElement extends HTMLElement {
+ src: string;
+ media: string;
+ type: string;
+}
+declare var HTMLSourceElement: {
+ prototype: HTMLSourceElement;
+ new(): HTMLSourceElement;
+}
+
+interface CanvasGradient {
+ addColorStop(offset: number, color: string): void;
+}
+declare var CanvasGradient: {
+ prototype: CanvasGradient;
+ new(): CanvasGradient;
+}
+
+interface KeyboardEvent extends UIEvent, KeyboardEventExtensions {
+ location: number;
+ shiftKey: bool;
+ locale: string;
+ key: string;
+ altKey: bool;
+ metaKey: bool;
+ char: string;
+ ctrlKey: bool;
+ repeat: bool;
+ getModifierState(keyArg: string): bool;
+ initKeyboardEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, keyArg: string, locationArg: number, modifiersListArg: string, repeat: bool, locale: string): void;
+ DOM_KEY_LOCATION_RIGHT: number;
+ DOM_KEY_LOCATION_STANDARD: number;
+ DOM_KEY_LOCATION_LEFT: number;
+ DOM_KEY_LOCATION_NUMPAD: number;
+ DOM_KEY_LOCATION_JOYSTICK: number;
+ DOM_KEY_LOCATION_MOBILE: number;
+}
+declare var KeyboardEvent: {
+ prototype: KeyboardEvent;
+ new(): KeyboardEvent;
+ DOM_KEY_LOCATION_RIGHT: number;
+ DOM_KEY_LOCATION_STANDARD: number;
+ DOM_KEY_LOCATION_LEFT: number;
+ DOM_KEY_LOCATION_NUMPAD: number;
+ DOM_KEY_LOCATION_JOYSTICK: number;
+ DOM_KEY_LOCATION_MOBILE: number;
+}
+
+interface Document extends Node, DocumentStyle, DocumentRange, HTMLDocument, NodeSelector, DocumentEvent, DocumentTraversal, DocumentView, SVGDocument {
+ doctype: DocumentType;
+ xmlVersion: string;
+ implementation: DOMImplementation;
+ xmlEncoding: string;
+ xmlStandalone: bool;
+ documentElement: HTMLElement;
+ inputEncoding: string;
+ createElement(tagName: string): HTMLElement;
+ adoptNode(source: Node): Node;
+ createComment(data: string): Comment;
+ createDocumentFragment(): DocumentFragment;
+ getElementsByTagName(tagname: string): NodeList;
+ getElementsByTagNameNS(namespaceURI: string, localName: string): NodeList;
+ createProcessingInstruction(target: string, data: string): ProcessingInstruction;
+ createElementNS(namespaceURI: string, qualifiedName: string): Element;
+ createAttribute(name: string): Attr;
+ createTextNode(data: string): Text;
+ importNode(importedNode: Node, deep: bool): Node;
+ createCDATASection(data: string): CDATASection;
+ createAttributeNS(namespaceURI: string, qualifiedName: string): Attr;
+ getElementById(elementId: string): HTMLElement;
+}
+declare var Document: {
+ prototype: Document;
+ new(): Document;
+}
+
+interface MessageEvent extends Event {
+ source: Window;
+ origin: string;
+ data: any;
+ initMessageEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, dataArg: any, originArg: string, lastEventIdArg: string, sourceArg: Window): void;
+}
+declare var MessageEvent: {
+ prototype: MessageEvent;
+ new(): MessageEvent;
+}
+
+interface SVGElement extends Element, SVGElementEventHandlers {
+ xmlbase: string;
+ viewportElement: SVGElement;
+ id: string;
+ ownerSVGElement: SVGSVGElement;
+}
+declare var SVGElement: {
+ prototype: SVGElement;
+ new(): SVGElement;
+}
+
+interface HTMLScriptElement extends HTMLElement {
+ defer: bool;
+ text: string;
+ src: string;
+ htmlFor: string;
+ charset: string;
+ type: string;
+ event: string;
+}
+declare var HTMLScriptElement: {
+ prototype: HTMLScriptElement;
+ new(): HTMLScriptElement;
+}
+
+interface MSHTMLBodyElementExtensions extends DOML2DeprecatedWordWrapSuppression_HTMLBodyElement {
+ scroll: string;
+ bottomMargin: any;
+ topMargin: any;
+ rightMargin: any;
+ bgProperties: string;
+ leftMargin: any;
+ createTextRange(): TextRange;
+}
+
+interface HTMLTableRowElement extends HTMLElement, MSBorderColorHighlightStyle_HTMLTableRowElement, HTMLTableAlignment, MSBorderColorStyle_HTMLTableRowElement, DOML2DeprecatedAlignmentStyle_HTMLTableRowElement, DOML2DeprecatedBackgroundColorStyle, MSHTMLTableRowElementExtensions {
+ rowIndex: number;
+ cells: HTMLCollection;
+ sectionRowIndex: number;
+ deleteCell(index?: number): void;
+ insertCell(index?: number): HTMLElement;
+}
+declare var HTMLTableRowElement: {
+ prototype: HTMLTableRowElement;
+ new(): HTMLTableRowElement;
+}
+
+interface MSCommentExtensions {
+ text: string;
+}
+
+interface DOML2DeprecatedMarginStyle_HTMLMarqueeElement {
+ vspace: number;
+ hspace: number;
+}
+
+interface MSCSSRuleList {
+ length: number;
+ item(index?: number): CSSStyleRule;
+ [index: number]: CSSStyleRule;
+}
+declare var MSCSSRuleList: {
+ prototype: MSCSSRuleList;
+ new(): MSCSSRuleList;
+}
+
+interface CanvasRenderingContext2D {
+ shadowOffsetX: number;
+ lineWidth: number;
+ miterLimit: number;
+ canvas: HTMLCanvasElement;
+ strokeStyle: any;
+ font: string;
+ globalAlpha: number;
+ globalCompositeOperation: string;
+ shadowOffsetY: number;
+ fillStyle: any;
+ lineCap: string;
+ shadowBlur: number;
+ textAlign: string;
+ textBaseline: string;
+ shadowColor: string;
+ lineJoin: string;
+ restore(): void;
+ setTransform(m11: number, m12: number, m21: number, m22: number, dx: number, dy: number): void;
+ save(): void;
+ arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: bool): void;
+ measureText(text: string): TextMetrics;
+ isPointInPath(x: number, y: number): bool;
+ quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+ putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX?: number, dirtyY?: number, dirtyWidth?: number, dirtyHeight?: number): void;
+ rotate(angle: number): void;
+ fillText(text: string, x: number, y: number, maxWidth?: number): void;
+ translate(x: number, y: number): void;
+ scale(x: number, y: number): void;
+ createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
+ lineTo(x: number, y: number): void;
+ fill(): void;
+ createPattern(image: HTMLElement, repetition: string): CanvasPattern;
+ closePath(): void;
+ rect(x: number, y: number, w: number, h: number): void;
+ clip(): void;
+ createImageData(imageDataOrSw: any, sh?: number): ImageData;
+ clearRect(x: number, y: number, w: number, h: number): void;
+ moveTo(x: number, y: number): void;
+ getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
+ fillRect(x: number, y: number, w: number, h: number): void;
+ bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+ drawImage(image: HTMLElement, offsetX: number, offsetY: number, width?: number, height?: number, canvasOffsetX?: number, canvasOffsetY?: number, canvasImageWidth?: number, canvasImageHeight?: number): void;
+ transform(m11: number, m12: number, m21: number, m22: number, dx: number, dy: number): void;
+ stroke(): void;
+ strokeRect(x: number, y: number, w: number, h: number): void;
+ strokeText(text: string, x: number, y: number, maxWidth?: number): void;
+ beginPath(): void;
+ arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+ createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
+}
+declare var CanvasRenderingContext2D: {
+ prototype: CanvasRenderingContext2D;
+ new(): CanvasRenderingContext2D;
+}
+
+interface SVGPathSegLinetoHorizontalAbs extends SVGPathSeg {
+ x: number;
+}
+declare var SVGPathSegLinetoHorizontalAbs: {
+ prototype: SVGPathSegLinetoHorizontalAbs;
+ new(): SVGPathSegLinetoHorizontalAbs;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLObjectElement {
+ align: string;
+}
+
+interface DOML2DeprecatedBorderStyle_MSHTMLIFrameElementExtensions {
+ border: string;
+}
+
+interface MSHTMLElementRangeExtensions {
+ createControlRange(): ControlRangeCollection;
+}
+
+interface SVGPathSegArcAbs extends SVGPathSeg {
+ y: number;
+ sweepFlag: bool;
+ r2: number;
+ x: number;
+ angle: number;
+ r1: number;
+ largeArcFlag: bool;
+}
+declare var SVGPathSegArcAbs: {
+ prototype: SVGPathSegArcAbs;
+ new(): SVGPathSegArcAbs;
+}
+
+interface MSScreenExtensions {
+ deviceXDPI: number;
+ fontSmoothingEnabled: bool;
+ bufferDepth: number;
+ logicalXDPI: number;
+ systemXDPI: number;
+ logicalYDPI: number;
+ systemYDPI: number;
+ updateInterval: number;
+ deviceYDPI: number;
+}
+
+interface HTMLHtmlElement extends HTMLElement, HTMLHtmlElementDOML2Deprecated {
+}
+declare var HTMLHtmlElement: {
+ prototype: HTMLHtmlElement;
+ new(): HTMLHtmlElement;
+}
+
+interface MSBorderColorStyle {
+ borderColor: any;
+}
+
+interface SVGTransformList {
+ numberOfItems: number;
+ getItem(index: number): SVGTransform;
+ consolidate(): SVGTransform;
+ clear(): void;
+ appendItem(newItem: SVGTransform): SVGTransform;
+ initialize(newItem: SVGTransform): SVGTransform;
+ removeItem(index: number): SVGTransform;
+ insertItemBefore(newItem: SVGTransform, index: number): SVGTransform;
+ replaceItem(newItem: SVGTransform, index: number): SVGTransform;
+ createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
+}
+declare var SVGTransformList: {
+ prototype: SVGTransformList;
+ new(): SVGTransformList;
+}
+
+interface SVGPathSegClosePath extends SVGPathSeg {
+}
+declare var SVGPathSegClosePath: {
+ prototype: SVGPathSegClosePath;
+ new(): SVGPathSegClosePath;
+}
+
+interface DOML2DeprecatedMarginStyle_MSHTMLIFrameElementExtensions {
+ vspace: number;
+ hspace: number;
+}
+
+interface HTMLFrameElement extends HTMLElement, GetSVGDocument, MSHTMLFrameElementExtensions, MSDataBindingExtensions, MSBorderColorStyle_HTMLFrameElement {
+ scrolling: string;
+ marginHeight: string;
+ src: string;
+ name: string;
+ marginWidth: string;
+ contentDocument: Document;
+ longDesc: string;
+ noResize: bool;
+}
+declare var HTMLFrameElement: {
+ prototype: HTMLFrameElement;
+ new(): HTMLFrameElement;
+}
+
+interface SVGAnimatedLength {
+ animVal: SVGLength;
+ baseVal: SVGLength;
+}
+declare var SVGAnimatedLength: {
+ prototype: SVGAnimatedLength;
+ new(): SVGAnimatedLength;
+}
+
+interface CSSMediaRule extends CSSRule {
+ media: MediaList;
+ cssRules: CSSRuleList;
+ insertRule(rule: string, index?: number): number;
+ deleteRule(index?: number): void;
+}
+declare var CSSMediaRule: {
+ prototype: CSSMediaRule;
+ new(): CSSMediaRule;
+}
+
+interface HTMLQuoteElement extends HTMLElement, MSHTMLQuoteElementExtensions {
+ cite: string;
+}
+declare var HTMLQuoteElement: {
+ prototype: HTMLQuoteElement;
+ new(): HTMLQuoteElement;
+}
+
+interface SVGDefsElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests {
+}
+declare var SVGDefsElement: {
+ prototype: SVGDefsElement;
+ new(): SVGDefsElement;
+}
+
+interface SVGAnimatedPoints {
+ points: SVGPointList;
+ animatedPoints: SVGPointList;
+}
+
+interface WindowModal {
+ dialogArguments: any;
+ returnValue: any;
+}
+
+interface MSHTMLButtonElementExtensions {
+ status: any;
+ createTextRange(): TextRange;
+}
+
+interface XMLHttpRequest extends EventTarget, MSXMLHttpRequestExtensions {
+ onreadystatechange: (ev: Event) => any;
+ status: number;
+ onload: (ev: Event) => any;
+ readyState: number;
+ responseText: string;
+ responseXML: Document;
+ statusText: string;
+ open(method: string, url: string, async?: bool, user?: string, password?: string): void;
+ send(data?: any): void;
+ abort(): void;
+ getAllResponseHeaders(): string;
+ setRequestHeader(header: string, value: string): void;
+ getResponseHeader(header: string): string;
+ LOADING: number;
+ DONE: number;
+ UNSENT: number;
+ OPENED: number;
+ HEADERS_RECEIVED: number;
+}
+declare var XMLHttpRequest: {
+ prototype: XMLHttpRequest;
+ new (): XMLHttpRequest;
+ LOADING: number;
+ DONE: number;
+ UNSENT: number;
+ OPENED: number;
+ HEADERS_RECEIVED: number;
+}
+
+interface HTMLTableHeaderCellElement extends HTMLTableCellElement, HTMLTableHeaderCellScope {
+}
+declare var HTMLTableHeaderCellElement: {
+ prototype: HTMLTableHeaderCellElement;
+ new(): HTMLTableHeaderCellElement;
+}
+
+interface HTMLDListElement extends HTMLElement, DOML2DeprecatedListSpaceReduction, MSHTMLDListElementExtensions {
+}
+declare var HTMLDListElement: {
+ prototype: HTMLDListElement;
+ new(): HTMLDListElement;
+}
+
+interface MSDataBindingExtensions {
+ dataSrc: string;
+ dataFormatAs: string;
+ dataFld: string;
+}
+
+interface SVGEllipseElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests {
+ ry: SVGAnimatedLength;
+ cx: SVGAnimatedLength;
+ rx: SVGAnimatedLength;
+ cy: SVGAnimatedLength;
+}
+declare var SVGEllipseElement: {
+ prototype: SVGEllipseElement;
+ new(): SVGEllipseElement;
+}
+
+interface SVGPathSegLinetoHorizontalRel extends SVGPathSeg {
+ x: number;
+}
+declare var SVGPathSegLinetoHorizontalRel: {
+ prototype: SVGPathSegLinetoHorizontalRel;
+ new(): SVGPathSegLinetoHorizontalRel;
+}
+
+interface SVGAElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGURIReference {
+ target: SVGAnimatedString;
+}
+declare var SVGAElement: {
+ prototype: SVGAElement;
+ new(): SVGAElement;
+}
+
+interface MSHTMLMetaElementExtensions {
+ url: string;
+ charset: string;
+}
+
+interface SVGStylable {
+ className: SVGAnimatedString;
+ style: CSSStyleDeclaration;
+}
+
+interface MSHTMLTableCellElementExtensions {
+}
+
+interface HTMLFrameSetElement extends HTMLElement, MSHTMLFrameSetElementExtensions, MSBorderColorStyle_HTMLFrameSetElement {
+ onresize: (ev: UIEvent) => any;
+ ononline: (ev: Event) => any;
+ onafterprint: (ev: Event) => any;
+ onbeforeprint: (ev: Event) => any;
+ onoffline: (ev: Event) => any;
+ rows: string;
+ cols: string;
+ onblur: (ev: FocusEvent) => any;
+ onunload: (ev: Event) => any;
+ onhashchange: (ev: Event) => any;
+ onfocus: (ev: FocusEvent) => any;
+ onmessage: (ev: MessageEvent) => any;
+ onload: (ev: Event) => any;
+ onerror: (ev: Event) => any;
+ onbeforeunload: (ev: BeforeUnloadEvent) => any;
+ onstorage: (ev: StorageEvent) => any;
+}
+declare var HTMLFrameSetElement: {
+ prototype: HTMLFrameSetElement;
+ new(): HTMLFrameSetElement;
+}
+
+interface SVGTransformable extends SVGLocatable {
+ transform: SVGAnimatedTransformList;
+}
+
+interface Screen extends MSScreenExtensions {
+ width: number;
+ colorDepth: number;
+ availWidth: number;
+ pixelDepth: number;
+ availHeight: number;
+ height: number;
+}
+declare var Screen: {
+ prototype: Screen;
+ new(): Screen;
+}
+
+interface NavigatorGeolocation {
+ geolocation: Geolocation;
+}
+
+interface Coordinates {
+ altitudeAccuracy: number;
+ longitude: number;
+ latitude: number;
+ speed: number;
+ heading: number;
+ altitude: number;
+ accuracy: number;
+}
+declare var Coordinates: {
+ prototype: Coordinates;
+ new(): Coordinates;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLTableColElement {
+ align: string;
+}
+
+interface EventListener {
+ (evt: Event): void;
+}
+
+interface SVGLangSpace {
+ xmllang: string;
+ xmlspace: string;
+}
+
+interface DataTransfer {
+ effectAllowed: string;
+ dropEffect: string;
+ clearData(format?: string): bool;
+ setData(format: string, data: string): bool;
+ getData(format: string): string;
+}
+declare var DataTransfer: {
+ prototype: DataTransfer;
+ new(): DataTransfer;
+}
+
+interface FocusEvent extends UIEvent {
+ relatedTarget: EventTarget;
+ initFocusEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, relatedTargetArg: EventTarget): void;
+}
+declare var FocusEvent: {
+ prototype: FocusEvent;
+ new(): FocusEvent;
+}
+
+interface Range {
+ startOffset: number;
+ collapsed: bool;
+ endOffset: number;
+ startContainer: Node;
+ endContainer: Node;
+ commonAncestorContainer: Node;
+ setStart(refNode: Node, offset: number): void;
+ setEndBefore(refNode: Node): void;
+ setStartBefore(refNode: Node): void;
+ selectNode(refNode: Node): void;
+ detach(): void;
+ getBoundingClientRect(): ClientRect;
+ toString(): string;
+ compareBoundaryPoints(how: number, sourceRange: Range): number;
+ insertNode(newNode: Node): void;
+ collapse(toStart: bool): void;
+ selectNodeContents(refNode: Node): void;
+ cloneContents(): DocumentFragment;
+ setEnd(refNode: Node, offset: number): void;
+ cloneRange(): Range;
+ getClientRects(): ClientRectList;
+ surroundContents(newParent: Node): void;
+ deleteContents(): void;
+ setStartAfter(refNode: Node): void;
+ extractContents(): DocumentFragment;
+ setEndAfter(refNode: Node): void;
+ END_TO_END: number;
+ START_TO_START: number;
+ START_TO_END: number;
+ END_TO_START: number;
+}
+declare var Range: {
+ prototype: Range;
+ new(): Range;
+ END_TO_END: number;
+ START_TO_START: number;
+ START_TO_END: number;
+ END_TO_START: number;
+}
+
+interface MSHTMLPreElementExtensions extends DOML2DeprecatedTextFlowControl_HTMLBlockElement {
+ cite: string;
+}
+
+interface SVGPoint {
+ y: number;
+ x: number;
+ matrixTransform(matrix: SVGMatrix): SVGPoint;
+}
+declare var SVGPoint: {
+ prototype: SVGPoint;
+ new(): SVGPoint;
+}
+
+interface MSPluginsCollection {
+ length: number;
+ refresh(reload?: bool): void;
+}
+declare var MSPluginsCollection: {
+ prototype: MSPluginsCollection;
+ new(): MSPluginsCollection;
+}
+
+interface MSHTMLFontElementExtensions {
+}
+
+interface SVGAnimatedNumberList {
+ animVal: SVGNumberList;
+ baseVal: SVGNumberList;
+}
+declare var SVGAnimatedNumberList: {
+ prototype: SVGAnimatedNumberList;
+ new(): SVGAnimatedNumberList;
+}
+
+interface SVGSVGElement extends SVGElement, SVGZoomAndPan, SVGLangSpace, SVGLocatable, SVGTests, SVGFitToViewBox, SVGSVGElementEventHandlers, SVGStylable, DocumentEvent, ViewCSS_SVGSVGElement {
+ width: SVGAnimatedLength;
+ x: SVGAnimatedLength;
+ contentStyleType: string;
+ screenPixelToMillimeterY: number;
+ height: SVGAnimatedLength;
+ contentScriptType: string;
+ pixelUnitToMillimeterX: number;
+ currentTranslate: SVGPoint;
+ y: SVGAnimatedLength;
+ viewport: SVGRect;
+ currentScale: number;
+ screenPixelToMillimeterX: number;
+ pixelUnitToMillimeterY: number;
+ setCurrentTime(seconds: number): void;
+ createSVGLength(): SVGLength;
+ getIntersectionList(rect: SVGRect, referenceElement: SVGElement): NodeList;
+ unpauseAnimations(): void;
+ createSVGRect(): SVGRect;
+ checkIntersection(element: SVGElement, rect: SVGRect): bool;
+ unsuspendRedrawAll(): void;
+ pauseAnimations(): void;
+ suspendRedraw(maxWaitMilliseconds: number): number;
+ deselectAll(): void;
+ createSVGAngle(): SVGAngle;
+ getEnclosureList(rect: SVGRect, referenceElement: SVGElement): NodeList;
+ createSVGTransform(): SVGTransform;
+ unsuspendRedraw(suspendHandleID: number): void;
+ forceRedraw(): void;
+ getCurrentTime(): number;
+ checkEnclosure(element: SVGElement, rect: SVGRect): bool;
+ createSVGMatrix(): SVGMatrix;
+ createSVGPoint(): SVGPoint;
+ createSVGNumber(): SVGNumber;
+ createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform;
+ getElementById(elementId: string): Element;
+}
+declare var SVGSVGElement: {
+ prototype: SVGSVGElement;
+ new(): SVGSVGElement;
+}
+
+interface HTMLLabelElement extends HTMLElement, MSDataBindingExtensions, MSHTMLLabelElementExtensions {
+ htmlFor: string;
+ form: HTMLFormElement;
+}
+declare var HTMLLabelElement: {
+ prototype: HTMLLabelElement;
+ new(): HTMLLabelElement;
+}
+
+interface MSResourceMetadata {
+ protocol: string;
+ fileSize: string;
+ fileUpdatedDate: string;
+ nameProp: string;
+ fileCreatedDate: string;
+ fileModifiedDate: string;
+ mimeType: string;
+}
+
+interface MSHTMLQuoteElementExtensions {
+ dateTime: string;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLIFrameElement {
+ align: string;
+}
+
+interface HTMLLegendElement extends HTMLElement, DOML2DeprecatedAlignmentStyle_HTMLLegendElement, MSDataBindingExtensions, MSHTMLLegendElementExtensions {
+ form: HTMLFormElement;
+}
+declare var HTMLLegendElement: {
+ prototype: HTMLLegendElement;
+ new(): HTMLLegendElement;
+}
+
+interface HTMLDirectoryElement extends HTMLElement, DOML2DeprecatedListSpaceReduction, MSHTMLDirectoryElementExtensions {
+}
+declare var HTMLDirectoryElement: {
+ prototype: HTMLDirectoryElement;
+ new(): HTMLDirectoryElement;
+}
+
+interface NavigatorAbilities {
+}
+
+interface MSHTMLImageElementExtensions {
+ href: string;
+}
+
+interface SVGAnimatedInteger {
+ animVal: number;
+ baseVal: number;
+}
+declare var SVGAnimatedInteger: {
+ prototype: SVGAnimatedInteger;
+ new(): SVGAnimatedInteger;
+}
+
+interface SVGTextElement extends SVGTextPositioningElement, SVGTransformable {
+}
+declare var SVGTextElement: {
+ prototype: SVGTextElement;
+ new(): SVGTextElement;
+}
+
+interface SVGTSpanElement extends SVGTextPositioningElement {
+}
+declare var SVGTSpanElement: {
+ prototype: SVGTSpanElement;
+ new(): SVGTSpanElement;
+}
+
+interface HTMLLIElement extends HTMLElement, DOML2DeprecatedListNumberingAndBulletStyle, MSHTMLLIElementExtensions {
+ value: number;
+}
+declare var HTMLLIElement: {
+ prototype: HTMLLIElement;
+ new(): HTMLLIElement;
+}
+
+interface SVGPathSegLinetoVerticalAbs extends SVGPathSeg {
+ y: number;
+}
+declare var SVGPathSegLinetoVerticalAbs: {
+ prototype: SVGPathSegLinetoVerticalAbs;
+ new(): SVGPathSegLinetoVerticalAbs;
+}
+
+interface ViewCSS {
+ getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration;
+}
+
+interface MSAttrExtensions {
+ expando: bool;
+}
+
+interface MSStorageExtensions {
+ remainingSpace: number;
+}
+
+interface SVGStyleElement extends SVGElement, SVGLangSpace {
+ media: string;
+ type: string;
+ title: string;
+}
+declare var SVGStyleElement: {
+ prototype: SVGStyleElement;
+ new(): SVGStyleElement;
+}
+
+interface MSCurrentStyleCSSProperties extends MSCSSProperties {
+ blockDirection: string;
+ clipBottom: string;
+ clipLeft: string;
+ clipRight: string;
+ clipTop: string;
+ hasLayout: string;
+}
+declare var MSCurrentStyleCSSProperties: {
+ prototype: MSCurrentStyleCSSProperties;
+ new(): MSCurrentStyleCSSProperties;
+}
+
+interface MSLinkStyleExtensions {
+ styleSheet: StyleSheet;
+}
+
+interface MSHTMLCollectionExtensions {
+ urns(urn: any): Object;
+ tags(tagName: any): Object;
+}
+
+interface DOML2DeprecatedWordWrapSuppression_HTMLDivElement {
+ noWrap: bool;
+}
+
+interface DocumentTraversal {
+ createNodeIterator(root: Node, whatToShow: number, filter: NodeFilterCallback, entityReferenceExpansion: bool): NodeIterator;
+ createTreeWalker(root: Node, whatToShow: number, filter: NodeFilterCallback, entityReferenceExpansion: bool): TreeWalker;
+}
+
+interface Storage extends MSStorageExtensions {
+ length: number;
+ getItem(key: string): any;
+ [key: string]: any;
+ setItem(key: string, data: string): void;
+ clear(): void;
+ removeItem(key: string): void;
+ key(index: number): string;
+ [index: number]: any;
+}
+declare var Storage: {
+ prototype: Storage;
+ new(): Storage;
+}
+
+interface HTMLTableHeaderCellScope {
+ scope: string;
+}
+
+interface HTMLIFrameElement extends HTMLElement, GetSVGDocument, MSHTMLIFrameElementExtensions, MSDataBindingExtensions, DOML2DeprecatedAlignmentStyle_HTMLIFrameElement {
+ width: string;
+ contentWindow: Window;
+ scrolling: string;
+ src: string;
+ marginHeight: string;
+ name: string;
+ marginWidth: string;
+ height: string;
+ contentDocument: Document;
+ longDesc: string;
+ frameBorder: string;
+}
+declare var HTMLIFrameElement: {
+ prototype: HTMLIFrameElement;
+ new(): HTMLIFrameElement;
+}
+
+interface MSNavigatorAbilities {
+ userLanguage: string;
+ plugins: MSPluginsCollection;
+ cookieEnabled: bool;
+ appCodeName: string;
+ cpuClass: string;
+ appMinorVersion: string;
+ connectionSpeed: number;
+ browserLanguage: string;
+ mimeTypes: MSMimeTypesCollection;
+ product: string;
+ systemLanguage: string;
+ javaEnabled(): bool;
+ taintEnabled(): bool;
+}
+
+interface TextRangeCollection {
+ length: number;
+ item(index: number): TextRange;
+ [index: number]: TextRange;
+}
+declare var TextRangeCollection: {
+ prototype: TextRangeCollection;
+ new(): TextRangeCollection;
+}
+
+interface HTMLBodyElement extends HTMLElement, HTMLBodyElementDOML2Deprecated, MSHTMLBodyElementExtensions, DOML2DeprecatedBackgroundStyle, DOML2DeprecatedBackgroundColorStyle {
+ onresize: (ev: UIEvent) => any;
+ ononline: (ev: Event) => any;
+ onafterprint: (ev: Event) => any;
+ onbeforeprint: (ev: Event) => any;
+ onoffline: (ev: Event) => any;
+ onblur: (ev: FocusEvent) => any;
+ onhashchange: (ev: Event) => any;
+ onunload: (ev: Event) => any;
+ onfocus: (ev: FocusEvent) => any;
+ onmessage: (ev: MessageEvent) => any;
+ onload: (ev: Event) => any;
+ onerror: (ev: Event) => any;
+ onbeforeunload: (ev: BeforeUnloadEvent) => any;
+ onstorage: (ev: StorageEvent) => any;
+}
+declare var HTMLBodyElement: {
+ prototype: HTMLBodyElement;
+ new(): HTMLBodyElement;
+}
+
+interface DocumentType extends Node {
+ name: string;
+ notations: NamedNodeMap;
+ systemId: string;
+ internalSubset: string;
+ entities: NamedNodeMap;
+ publicId: string;
+}
+declare var DocumentType: {
+ prototype: DocumentType;
+ new(): DocumentType;
+}
+
+interface MSHTMLInputElementExtensions extends DOML2DeprecatedMarginStyle_HTMLInputElement, DOML2DeprecatedBorderStyle_HTMLInputElement {
+ status: bool;
+ complete: bool;
+ createTextRange(): TextRange;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLLegendElement {
+ align: string;
+}
+
+interface SVGRadialGradientElement extends SVGGradientElement {
+ cx: SVGAnimatedLength;
+ r: SVGAnimatedLength;
+ cy: SVGAnimatedLength;
+ fx: SVGAnimatedLength;
+ fy: SVGAnimatedLength;
+}
+declare var SVGRadialGradientElement: {
+ prototype: SVGRadialGradientElement;
+ new(): SVGRadialGradientElement;
+}
+
+interface MutationEvent extends Event {
+ newValue: string;
+ attrChange: number;
+ attrName: string;
+ prevValue: string;
+ relatedNode: Node;
+ initMutationEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, relatedNodeArg: Node, prevValueArg: string, newValueArg: string, attrNameArg: string, attrChangeArg: number): void;
+ MODIFICATION: number;
+ REMOVAL: number;
+ ADDITION: number;
+}
+declare var MutationEvent: {
+ prototype: MutationEvent;
+ new(): MutationEvent;
+ MODIFICATION: number;
+ REMOVAL: number;
+ ADDITION: number;
+}
+
+interface DragEvent extends MouseEvent {
+ dataTransfer: DataTransfer;
+ initDragEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: bool, altKeyArg: bool, shiftKeyArg: bool, metaKeyArg: bool, buttonArg: number, relatedTargetArg: EventTarget, dataTransferArg: DataTransfer): void;
+}
+declare var DragEvent: {
+ prototype: DragEvent;
+ new(): DragEvent;
+}
+
+interface DOML2DeprecatedWidthStyle_HTMLTableCellElement {
+ width: number;
+}
+
+interface HTMLTableSectionElement extends HTMLElement, MSHTMLTableSectionElementExtensions, DOML2DeprecatedAlignmentStyle_HTMLTableSectionElement, HTMLTableAlignment {
+ rows: HTMLCollection;
+ deleteRow(index?: number): void;
+ insertRow(index?: number): HTMLElement;
+}
+declare var HTMLTableSectionElement: {
+ prototype: HTMLTableSectionElement;
+ new(): HTMLTableSectionElement;
+}
+
+interface DOML2DeprecatedListNumberingAndBulletStyle {
+ type: string;
+}
+
+interface HTMLInputElement extends HTMLElement, DOML2DeprecatedAlignmentStyle_HTMLInputElement, MSImageResourceExtensions_HTMLInputElement, MSHTMLInputElementExtensions, MSDataBindingExtensions {
+ width: string;
+ defaultChecked: bool;
+ alt: string;
+ accept: string;
+ value: string;
+ src: string;
+ useMap: string;
+ name: string;
+ form: HTMLFormElement;
+ selectionStart: number;
+ height: string;
+ indeterminate: bool;
+ readOnly: bool;
+ size: number;
+ checked: bool;
+ maxLength: number;
+ selectionEnd: number;
+ type: string;
+ defaultValue: string;
+ setSelectionRange(start: number, end: number): void;
+ select(): void;
+}
+declare var HTMLInputElement: {
+ prototype: HTMLInputElement;
+ new(): HTMLInputElement;
+}
+
+interface HTMLAnchorElement extends HTMLElement, MSHTMLAnchorElementExtensions, MSDataBindingExtensions {
+ rel: string;
+ protocol: string;
+ search: string;
+ coords: string;
+ hostname: string;
+ pathname: string;
+ target: string;
+ href: string;
+ name: string;
+ charset: string;
+ hreflang: string;
+ port: string;
+ host: string;
+ hash: string;
+ rev: string;
+ type: string;
+ shape: string;
+ toString(): string;
+}
+declare var HTMLAnchorElement: {
+ prototype: HTMLAnchorElement;
+ new(): HTMLAnchorElement;
+}
+
+interface SVGImageElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGURIReference {
+ y: SVGAnimatedLength;
+ width: SVGAnimatedLength;
+ preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
+ x: SVGAnimatedLength;
+ height: SVGAnimatedLength;
+}
+declare var SVGImageElement: {
+ prototype: SVGImageElement;
+ new(): SVGImageElement;
+}
+
+interface MSElementExtensions {
+ msMatchesSelector(selectors: string): bool;
+ fireEvent(eventName: string, eventObj?: any): bool;
+}
+
+interface HTMLParamElement extends HTMLElement {
+ value: string;
+ name: string;
+ type: string;
+ valueType: string;
+}
+declare var HTMLParamElement: {
+ prototype: HTMLParamElement;
+ new(): HTMLParamElement;
+}
+
+interface MSHTMLDocumentViewExtensions {
+ createStyleSheet(href?: string, index?: number): CSSStyleSheet;
+}
+
+interface SVGAnimatedNumber {
+ animVal: number;
+ baseVal: number;
+}
+declare var SVGAnimatedNumber: {
+ prototype: SVGAnimatedNumber;
+ new(): SVGAnimatedNumber;
+}
+
+interface PerformanceTiming {
+ redirectStart: number;
+ domainLookupEnd: number;
+ responseStart: number;
+ domComplete: number;
+ domainLookupStart: number;
+ loadEventStart: number;
+ msFirstPaint: number;
+ unloadEventEnd: number;
+ fetchStart: number;
+ requestStart: number;
+ domInteractive: number;
+ navigationStart: number;
+ connectEnd: number;
+ loadEventEnd: number;
+ connectStart: number;
+ responseEnd: number;
+ domLoading: number;
+ redirectEnd: number;
+ unloadEventStart: number;
+ domContentLoadedEventStart: number;
+ domContentLoadedEventEnd: number;
+ toJSON(): any;
+}
+declare var PerformanceTiming: {
+ prototype: PerformanceTiming;
+ new(): PerformanceTiming;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLInputElement {
+ align: string;
+}
+
+interface HTMLPreElement extends HTMLElement, DOML2DeprecatedWidthStyle, MSHTMLPreElementExtensions {
+}
+declare var HTMLPreElement: {
+ prototype: HTMLPreElement;
+ new(): HTMLPreElement;
+}
+
+interface EventException {
+ code: number;
+ message: string;
+ toString(): string;
+ DISPATCH_REQUEST_ERR: number;
+ UNSPECIFIED_EVENT_TYPE_ERR: number;
+}
+declare var EventException: {
+ prototype: EventException;
+ new(): EventException;
+ DISPATCH_REQUEST_ERR: number;
+ UNSPECIFIED_EVENT_TYPE_ERR: number;
+}
+
+interface MSBorderColorHighlightStyle_HTMLTableCellElement {
+ borderColorLight: any;
+ borderColorDark: any;
+}
+
+interface DOMHTMLImplementation {
+ createHTMLDocument(title: string): Document;
+}
+
+interface NavigatorOnLine {
+ onLine: bool;
+}
+
+interface SVGElementEventHandlers {
+ onmouseover: (ev: MouseEvent) => any;
+ onmousemove: (ev: MouseEvent) => any;
+ onmouseout: (ev: MouseEvent) => any;
+ ondblclick: (ev: MouseEvent) => any;
+ onfocusout: (ev: FocusEvent) => any;
+ onfocusin: (ev: FocusEvent) => any;
+ onmousedown: (ev: MouseEvent) => any;
+ onmouseup: (ev: MouseEvent) => any;
+ onload: (ev: Event) => any;
+ onclick: (ev: MouseEvent) => any;
+}
+
+interface WindowLocalStorage {
+ localStorage: Storage;
+}
+
+interface SVGMetadataElement extends SVGElement {
+}
+declare var SVGMetadataElement: {
+ prototype: SVGMetadataElement;
+ new(): SVGMetadataElement;
+}
+
+interface SVGPathSegArcRel extends SVGPathSeg {
+ y: number;
+ sweepFlag: bool;
+ r2: number;
+ x: number;
+ angle: number;
+ r1: number;
+ largeArcFlag: bool;
+}
+declare var SVGPathSegArcRel: {
+ prototype: SVGPathSegArcRel;
+ new(): SVGPathSegArcRel;
+}
+
+interface SVGPathSegMovetoAbs extends SVGPathSeg {
+ y: number;
+ x: number;
+}
+declare var SVGPathSegMovetoAbs: {
+ prototype: SVGPathSegMovetoAbs;
+ new(): SVGPathSegMovetoAbs;
+}
+
+interface SVGStringList {
+ numberOfItems: number;
+ replaceItem(newItem: string, index: number): string;
+ getItem(index: number): string;
+ clear(): void;
+ appendItem(newItem: string): string;
+ initialize(newItem: string): string;
+ removeItem(index: number): string;
+ insertItemBefore(newItem: string, index: number): string;
+}
+declare var SVGStringList: {
+ prototype: SVGStringList;
+ new(): SVGStringList;
+}
+
+interface XDomainRequest {
+ timeout: number;
+ onerror: (ev: Event) => any;
+ onload: (ev: Event) => any;
+ onprogress: (ev: any) => any;
+ ontimeout: (ev: Event) => any;
+ responseText: string;
+ contentType: string;
+ open(method: string, url: string): void;
+ abort(): void;
+ send(data?: any): void;
+}
+declare var XDomainRequest: {
+ prototype: XDomainRequest;
+ new (): XDomainRequest;
+}
+
+interface DOML2DeprecatedBackgroundColorStyle {
+ bgColor: any;
+}
+
+interface ElementTraversal {
+ childElementCount: number;
+ previousElementSibling: Element;
+ lastElementChild: Element;
+ nextElementSibling: Element;
+ firstElementChild: Element;
+}
+
+interface SVGLength {
+ valueAsString: string;
+ valueInSpecifiedUnits: number;
+ value: number;
+ unitType: number;
+ newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
+ convertToSpecifiedUnits(unitType: number): void;
+ SVG_LENGTHTYPE_NUMBER: number;
+ SVG_LENGTHTYPE_CM: number;
+ SVG_LENGTHTYPE_PC: number;
+ SVG_LENGTHTYPE_PERCENTAGE: number;
+ SVG_LENGTHTYPE_MM: number;
+ SVG_LENGTHTYPE_PT: number;
+ SVG_LENGTHTYPE_IN: number;
+ SVG_LENGTHTYPE_EMS: number;
+ SVG_LENGTHTYPE_PX: number;
+ SVG_LENGTHTYPE_UNKNOWN: number;
+ SVG_LENGTHTYPE_EXS: number;
+}
+declare var SVGLength: {
+ prototype: SVGLength;
+ new(): SVGLength;
+ SVG_LENGTHTYPE_NUMBER: number;
+ SVG_LENGTHTYPE_CM: number;
+ SVG_LENGTHTYPE_PC: number;
+ SVG_LENGTHTYPE_PERCENTAGE: number;
+ SVG_LENGTHTYPE_MM: number;
+ SVG_LENGTHTYPE_PT: number;
+ SVG_LENGTHTYPE_IN: number;
+ SVG_LENGTHTYPE_EMS: number;
+ SVG_LENGTHTYPE_PX: number;
+ SVG_LENGTHTYPE_UNKNOWN: number;
+ SVG_LENGTHTYPE_EXS: number;
+}
+
+interface SVGPolygonElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGAnimatedPoints, SVGTests {
+}
+declare var SVGPolygonElement: {
+ prototype: SVGPolygonElement;
+ new(): SVGPolygonElement;
+}
+
+interface HTMLPhraseElement extends HTMLElement {
+ dateTime: string;
+ cite: string;
+}
+declare var HTMLPhraseElement: {
+ prototype: HTMLPhraseElement;
+ new(): HTMLPhraseElement;
+}
+
+interface MSHTMLAreaElementExtensions {
+}
+
+interface SVGPathSegCurvetoCubicRel extends SVGPathSeg {
+ y: number;
+ y1: number;
+ x2: number;
+ x: number;
+ x1: number;
+ y2: number;
+}
+declare var SVGPathSegCurvetoCubicRel: {
+ prototype: SVGPathSegCurvetoCubicRel;
+ new(): SVGPathSegCurvetoCubicRel;
+}
+
+interface MSEventObj {
+ nextPage: string;
+ keyCode: number;
+ toElement: Element;
+ returnValue: any;
+ dataFld: string;
+ y: number;
+ dataTransfer: DataTransfer;
+ propertyName: string;
+ url: string;
+ offsetX: number;
+ recordset: Object;
+ screenX: number;
+ buttonID: number;
+ wheelDelta: number;
+ reason: number;
+ origin: string;
+ data: string;
+ srcFilter: Object;
+ boundElements: HTMLCollection;
+ cancelBubble: bool;
+ altLeft: bool;
+ behaviorCookie: number;
+ bookmarks: BookmarkCollection;
+ type: string;
+ repeat: bool;
+ srcElement: Element;
+ source: Window;
+ fromElement: Element;
+ offsetY: number;
+ x: number;
+ behaviorPart: number;
+ qualifier: string;
+ altKey: bool;
+ ctrlKey: bool;
+ clientY: number;
+ shiftKey: bool;
+ shiftLeft: bool;
+ contentOverflow: bool;
+ screenY: number;
+ ctrlLeft: bool;
+ button: number;
+ srcUrn: string;
+ clientX: number;
+ actionURL: string;
+ getAttribute(strAttributeName: string, lFlags?: number): any;
+ setAttribute(strAttributeName: string, AttributeValue: any, lFlags?: number): void;
+ removeAttribute(strAttributeName: string, lFlags?: number): bool;
+}
+declare var MSEventObj: {
+ prototype: MSEventObj;
+ new(): MSEventObj;
+}
+
+interface SVGTextContentElement extends SVGElement, SVGStylable, SVGLangSpace, SVGTests {
+ textLength: SVGAnimatedLength;
+ lengthAdjust: SVGAnimatedEnumeration;
+ getCharNumAtPosition(point: SVGPoint): number;
+ getStartPositionOfChar(charnum: number): SVGPoint;
+ getExtentOfChar(charnum: number): SVGRect;
+ getComputedTextLength(): number;
+ getSubStringLength(charnum: number, nchars: number): number;
+ selectSubString(charnum: number, nchars: number): void;
+ getNumberOfChars(): number;
+ getRotationOfChar(charnum: number): number;
+ getEndPositionOfChar(charnum: number): SVGPoint;
+ LENGTHADJUST_SPACING: number;
+ LENGTHADJUST_SPACINGANDGLYPHS: number;
+ LENGTHADJUST_UNKNOWN: number;
+}
+declare var SVGTextContentElement: {
+ prototype: SVGTextContentElement;
+ new(): SVGTextContentElement;
+ LENGTHADJUST_SPACING: number;
+ LENGTHADJUST_SPACINGANDGLYPHS: number;
+ LENGTHADJUST_UNKNOWN: number;
+}
+
+interface DOML2DeprecatedColorProperty {
+ color: string;
+}
+
+interface MSHTMLLIElementExtensions {
+}
+
+interface HTMLCanvasElement extends HTMLElement {
+ width: number;
+ height: number;
+ toDataURL(): string;
+ toDataURL(type: string, ...args: any[]): string;
+ getContext(contextId: string): CanvasRenderingContext2D;
+}
+declare var HTMLCanvasElement: {
+ prototype: HTMLCanvasElement;
+ new(): HTMLCanvasElement;
+}
+
+interface HTMLTitleElement extends HTMLElement {
+ text: string;
+}
+declare var HTMLTitleElement: {
+ prototype: HTMLTitleElement;
+ new(): HTMLTitleElement;
+}
+
+interface Location {
+ hash: string;
+ protocol: string;
+ search: string;
+ href: string;
+ hostname: string;
+ port: string;
+ pathname: string;
+ host: string;
+ reload(flag?: bool): void;
+ replace(url: string): void;
+ assign(url: string): void;
+ toString(): string;
+}
+declare var Location: {
+ prototype: Location;
+ new(): Location;
+}
+
+interface HTMLStyleElement extends HTMLElement, MSLinkStyleExtensions, LinkStyle {
+ media: string;
+ type: string;
+}
+declare var HTMLStyleElement: {
+ prototype: HTMLStyleElement;
+ new(): HTMLStyleElement;
+}
+
+interface MSHTMLOptGroupElementExtensions {
+ index: number;
+ defaultSelected: bool;
+ text: string;
+ value: string;
+ form: HTMLFormElement;
+ selected: bool;
+}
+
+interface MSBorderColorHighlightStyle {
+ borderColorLight: any;
+ borderColorDark: any;
+}
+
+interface DOML2DeprecatedSizeProperty_HTMLBaseFontElement {
+ size: number;
+}
+
+interface SVGTransform {
+ type: number;
+ angle: number;
+ matrix: SVGMatrix;
+ setTranslate(tx: number, ty: number): void;
+ setScale(sx: number, sy: number): void;
+ setMatrix(matrix: SVGMatrix): void;
+ setSkewY(angle: number): void;
+ setRotate(angle: number, cx: number, cy: number): void;
+ setSkewX(angle: number): void;
+ SVG_TRANSFORM_SKEWX: number;
+ SVG_TRANSFORM_UNKNOWN: number;
+ SVG_TRANSFORM_SCALE: number;
+ SVG_TRANSFORM_TRANSLATE: number;
+ SVG_TRANSFORM_MATRIX: number;
+ SVG_TRANSFORM_ROTATE: number;
+ SVG_TRANSFORM_SKEWY: number;
+}
+declare var SVGTransform: {
+ prototype: SVGTransform;
+ new(): SVGTransform;
+ SVG_TRANSFORM_SKEWX: number;
+ SVG_TRANSFORM_UNKNOWN: number;
+ SVG_TRANSFORM_SCALE: number;
+ SVG_TRANSFORM_TRANSLATE: number;
+ SVG_TRANSFORM_MATRIX: number;
+ SVG_TRANSFORM_ROTATE: number;
+ SVG_TRANSFORM_SKEWY: number;
+}
+
+interface MSCSSFilter {
+ Percent: number;
+ Enabled: bool;
+ Duration: number;
+ Play(Duration: number): void;
+ Apply(): void;
+ Stop(): void;
+}
+declare var MSCSSFilter: {
+ prototype: MSCSSFilter;
+ new(): MSCSSFilter;
+}
+
+interface UIEvent extends Event {
+ detail: number;
+ view: AbstractView;
+ initUIEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number): void;
+}
+declare var UIEvent: {
+ prototype: UIEvent;
+ new(): UIEvent;
+}
+
+interface ViewCSS_SVGSVGElement {
+ getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration;
+}
+
+interface SVGURIReference {
+ href: SVGAnimatedString;
+}
+
+interface SVGPathSeg {
+ pathSegType: number;
+ pathSegTypeAsLetter: string;
+ PATHSEG_MOVETO_REL: number;
+ PATHSEG_LINETO_VERTICAL_REL: number;
+ PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
+ PATHSEG_CURVETO_QUADRATIC_REL: number;
+ PATHSEG_CURVETO_CUBIC_ABS: number;
+ PATHSEG_LINETO_HORIZONTAL_ABS: number;
+ PATHSEG_CURVETO_QUADRATIC_ABS: number;
+ PATHSEG_LINETO_ABS: number;
+ PATHSEG_CLOSEPATH: number;
+ PATHSEG_LINETO_HORIZONTAL_REL: number;
+ PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
+ PATHSEG_LINETO_REL: number;
+ PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
+ PATHSEG_ARC_REL: number;
+ PATHSEG_CURVETO_CUBIC_REL: number;
+ PATHSEG_UNKNOWN: number;
+ PATHSEG_LINETO_VERTICAL_ABS: number;
+ PATHSEG_ARC_ABS: number;
+ PATHSEG_MOVETO_ABS: number;
+ PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
+}
+declare var SVGPathSeg: {
+ PATHSEG_MOVETO_REL: number;
+ PATHSEG_LINETO_VERTICAL_REL: number;
+ PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number;
+ PATHSEG_CURVETO_QUADRATIC_REL: number;
+ PATHSEG_CURVETO_CUBIC_ABS: number;
+ PATHSEG_LINETO_HORIZONTAL_ABS: number;
+ PATHSEG_CURVETO_QUADRATIC_ABS: number;
+ PATHSEG_LINETO_ABS: number;
+ PATHSEG_CLOSEPATH: number;
+ PATHSEG_LINETO_HORIZONTAL_REL: number;
+ PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number;
+ PATHSEG_LINETO_REL: number;
+ PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number;
+ PATHSEG_ARC_REL: number;
+ PATHSEG_CURVETO_CUBIC_REL: number;
+ PATHSEG_UNKNOWN: number;
+ PATHSEG_LINETO_VERTICAL_ABS: number;
+ PATHSEG_ARC_ABS: number;
+ PATHSEG_MOVETO_ABS: number;
+ PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number;
+}
+
+interface WheelEvent extends MouseEvent {
+ deltaZ: number;
+ deltaX: number;
+ deltaMode: number;
+ deltaY: number;
+ initWheelEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, deltaXArg: number, deltaYArg: number, deltaZArg: number, deltaMode: number): void;
+ DOM_DELTA_PIXEL: number;
+ DOM_DELTA_LINE: number;
+ DOM_DELTA_PAGE: number;
+}
+declare var WheelEvent: {
+ prototype: WheelEvent;
+ new(): WheelEvent;
+ DOM_DELTA_PIXEL: number;
+ DOM_DELTA_LINE: number;
+ DOM_DELTA_PAGE: number;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLDivElement {
+ align: string;
+}
+
+interface MSEventAttachmentTarget {
+ attachEvent(event: string, listener: EventListener): bool;
+ detachEvent(event: string, listener: EventListener): void;
+}
+
+interface SVGNumber {
+ value: number;
+}
+declare var SVGNumber: {
+ prototype: SVGNumber;
+ new(): SVGNumber;
+}
+
+interface SVGPathElement extends SVGElement, SVGStylable, SVGAnimatedPathData, SVGTransformable, SVGLangSpace, SVGTests {
+ getPathSegAtLength(distance: number): number;
+ getPointAtLength(distance: number): SVGPoint;
+ createSVGPathSegCurvetoQuadraticAbs(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticAbs;
+ createSVGPathSegLinetoRel(x: number, y: number): SVGPathSegLinetoRel;
+ createSVGPathSegCurvetoQuadraticRel(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticRel;
+ createSVGPathSegCurvetoCubicAbs(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicAbs;
+ createSVGPathSegLinetoAbs(x: number, y: number): SVGPathSegLinetoAbs;
+ createSVGPathSegClosePath(): SVGPathSegClosePath;
+ createSVGPathSegCurvetoCubicRel(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicRel;
+ createSVGPathSegCurvetoQuadraticSmoothRel(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothRel;
+ createSVGPathSegMovetoRel(x: number, y: number): SVGPathSegMovetoRel;
+ createSVGPathSegCurvetoCubicSmoothAbs(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothAbs;
+ createSVGPathSegMovetoAbs(x: number, y: number): SVGPathSegMovetoAbs;
+ createSVGPathSegLinetoVerticalRel(y: number): SVGPathSegLinetoVerticalRel;
+ createSVGPathSegArcRel(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: bool, sweepFlag: bool): SVGPathSegArcRel;
+ createSVGPathSegCurvetoQuadraticSmoothAbs(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothAbs;
+ createSVGPathSegLinetoHorizontalRel(x: number): SVGPathSegLinetoHorizontalRel;
+ getTotalLength(): number;
+ createSVGPathSegCurvetoCubicSmoothRel(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothRel;
+ createSVGPathSegLinetoHorizontalAbs(x: number): SVGPathSegLinetoHorizontalAbs;
+ createSVGPathSegLinetoVerticalAbs(y: number): SVGPathSegLinetoVerticalAbs;
+ createSVGPathSegArcAbs(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: bool, sweepFlag: bool): SVGPathSegArcAbs;
+}
+declare var SVGPathElement: {
+ prototype: SVGPathElement;
+ new(): SVGPathElement;
+}
+
+interface MSCompatibleInfo {
+ version: string;
+ userAgent: string;
+}
+declare var MSCompatibleInfo: {
+ prototype: MSCompatibleInfo;
+ new(): MSCompatibleInfo;
+}
+
+interface MSHTMLDocumentEventExtensions {
+ createEventObject(eventObj?: any): MSEventObj;
+ fireEvent(eventName: string, eventObj?: any): bool;
+}
+
+interface Text extends CharacterData, MSNodeExtensions {
+ wholeText: string;
+ splitText(offset: number): Text;
+ replaceWholeText(content: string): Text;
+}
+declare var Text: {
+ prototype: Text;
+ new(): Text;
+}
+
+interface SVGAnimatedRect {
+ animVal: SVGRect;
+ baseVal: SVGRect;
+}
+declare var SVGAnimatedRect: {
+ prototype: SVGAnimatedRect;
+ new(): SVGAnimatedRect;
+}
+
+interface CSSNamespaceRule extends CSSRule {
+ namespaceURI: string;
+ prefix: string;
+}
+declare var CSSNamespaceRule: {
+ prototype: CSSNamespaceRule;
+ new(): CSSNamespaceRule;
+}
+
+interface HTMLUnknownElement extends HTMLElement, MSDataBindingRecordSetReadonlyExtensions, MSHTMLUnknownElementExtensions {
+}
+declare var HTMLUnknownElement: {
+ prototype: HTMLUnknownElement;
+ new(): HTMLUnknownElement;
+}
+
+interface SVGPathSegList {
+ numberOfItems: number;
+ replaceItem(newItem: SVGPathSeg, index: number): SVGPathSeg;
+ getItem(index: number): SVGPathSeg;
+ clear(): void;
+ appendItem(newItem: SVGPathSeg): SVGPathSeg;
+ initialize(newItem: SVGPathSeg): SVGPathSeg;
+ removeItem(index: number): SVGPathSeg;
+ insertItemBefore(newItem: SVGPathSeg, index: number): SVGPathSeg;
+}
+declare var SVGPathSegList: {
+ prototype: SVGPathSegList;
+ new(): SVGPathSegList;
+}
+
+interface HTMLAudioElement extends HTMLMediaElement {
+}
+declare var HTMLAudioElement: {
+ prototype: HTMLAudioElement;
+ new(): HTMLAudioElement;
+}
+
+interface MSImageResourceExtensions {
+ dynsrc: string;
+ vrml: string;
+ lowsrc: string;
+ start: string;
+ loop: number;
+}
+
+interface MSBorderColorHighlightStyle_HTMLTableRowElement {
+ borderColorLight: any;
+ borderColorDark: any;
+}
+
+interface PositionError {
+ code: number;
+ message: string;
+ toString(): string;
+ POSITION_UNAVAILABLE: number;
+ PERMISSION_DENIED: number;
+ TIMEOUT: number;
+}
+declare var PositionError: {
+ POSITION_UNAVAILABLE: number;
+ PERMISSION_DENIED: number;
+ TIMEOUT: number;
+}
+
+interface BrowserPublic {
+}
+declare var BrowserPublic: {
+ prototype: BrowserPublic;
+ new(): BrowserPublic;
+}
+
+interface HTMLTableCellElement extends HTMLElement, DOML2DeprecatedTableCellHeight, HTMLTableAlignment, MSBorderColorHighlightStyle_HTMLTableCellElement, DOML2DeprecatedWidthStyle_HTMLTableCellElement, DOML2DeprecatedBackgroundStyle, MSBorderColorStyle_HTMLTableCellElement, MSHTMLTableCellElementExtensions, DOML2DeprecatedAlignmentStyle_HTMLTableCellElement, HTMLTableHeaderCellScope, DOML2DeprecatedWordWrapSuppression, DOML2DeprecatedBackgroundColorStyle {
+ headers: string;
+ abbr: string;
+ rowSpan: number;
+ cellIndex: number;
+ colSpan: number;
+ axis: string;
+}
+declare var HTMLTableCellElement: {
+ prototype: HTMLTableCellElement;
+ new(): HTMLTableCellElement;
+}
+
+interface MSNamespaceInfoCollection {
+ length: number;
+ add(namespace?: string, urn?: string, implementationUrl?: any): Object;
+ item(index: any): Object;
+ [index: string]: Object;
+ (index: any): Object;
+}
+declare var MSNamespaceInfoCollection: {
+ prototype: MSNamespaceInfoCollection;
+ new(): MSNamespaceInfoCollection;
+}
+
+interface SVGElementInstance extends EventTarget {
+ previousSibling: SVGElementInstance;
+ parentNode: SVGElementInstance;
+ lastChild: SVGElementInstance;
+ nextSibling: SVGElementInstance;
+ childNodes: SVGElementInstanceList;
+ correspondingUseElement: SVGUseElement;
+ correspondingElement: SVGElement;
+ firstChild: SVGElementInstance;
+}
+declare var SVGElementInstance: {
+ prototype: SVGElementInstance;
+ new(): SVGElementInstance;
+}
+
+interface MSHTMLUListElementExtensions {
+}
+
+interface SVGCircleElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests {
+ cx: SVGAnimatedLength;
+ r: SVGAnimatedLength;
+ cy: SVGAnimatedLength;
+}
+declare var SVGCircleElement: {
+ prototype: SVGCircleElement;
+ new(): SVGCircleElement;
+}
+
+interface HTMLBaseFontElement extends HTMLElement, DOML2DeprecatedSizeProperty_HTMLBaseFontElement, DOML2DeprecatedColorProperty {
+ face: string;
+}
+declare var HTMLBaseFontElement: {
+ prototype: HTMLBaseFontElement;
+ new(): HTMLBaseFontElement;
+}
+
+interface CustomEvent extends Event {
+ detail: Object;
+ initCustomEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, detailArg: Object): void;
+}
+declare var CustomEvent: {
+ prototype: CustomEvent;
+ new(): CustomEvent;
+}
+
+interface CSSImportRule extends CSSRule {
+ styleSheet: CSSStyleSheet;
+ href: string;
+ media: MediaList;
+}
+declare var CSSImportRule: {
+ prototype: CSSImportRule;
+ new(): CSSImportRule;
+}
+
+interface StyleSheetList {
+ length: number;
+ item(index?: number): StyleSheet;
+ [index: number]: StyleSheet;
+}
+declare var StyleSheetList: {
+ prototype: StyleSheetList;
+ new(): StyleSheetList;
+}
+
+interface HTMLTextAreaElement extends HTMLElement, MSDataBindingExtensions, MSHTMLTextAreaElementExtensions {
+ value: string;
+ form: HTMLFormElement;
+ name: string;
+ selectionStart: number;
+ rows: number;
+ cols: number;
+ readOnly: bool;
+ wrap: string;
+ selectionEnd: number;
+ type: string;
+ defaultValue: string;
+ setSelectionRange(start: number, end: number): void;
+ select(): void;
+}
+declare var HTMLTextAreaElement: {
+ prototype: HTMLTextAreaElement;
+ new(): HTMLTextAreaElement;
+}
+
+interface MSHTMLFormElementExtensions {
+ encoding: string;
+}
+
+interface DOML2DeprecatedMarginStyle {
+ vspace: number;
+ hspace: number;
+}
+
+interface Geolocation {
+ clearWatch(watchId: number): void;
+ getCurrentPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): void;
+ watchPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): number;
+}
+declare var Geolocation: {
+ prototype: Geolocation;
+ new(): Geolocation;
+}
+
+interface MSWindowModeless {
+ dialogTop: any;
+ dialogLeft: any;
+ dialogWidth: any;
+ dialogHeight: any;
+ menuArguments: any;
+}
+
+interface HTMLMarqueeElement extends HTMLElement, DOML2DeprecatedMarginStyle_HTMLMarqueeElement, MSDataBindingExtensions, MSHTMLMarqueeElementExtensions, DOML2DeprecatedBackgroundColorStyle {
+ width: string;
+ onbounce: (ev: Event) => any;
+ trueSpeed: bool;
+ scrollAmount: number;
+ scrollDelay: number;
+ behavior: string;
+ height: string;
+ loop: number;
+ direction: string;
+ onstart: (ev: Event) => any;
+ onfinish: (ev: Event) => any;
+ stop(): void;
+ start(): void;
+}
+declare var HTMLMarqueeElement: {
+ prototype: HTMLMarqueeElement;
+ new(): HTMLMarqueeElement;
+}
+
+interface SVGRect {
+ y: number;
+ width: number;
+ x: number;
+ height: number;
+}
+declare var SVGRect: {
+ prototype: SVGRect;
+ new(): SVGRect;
+}
+
+interface MSNodeExtensions {
+ swapNode(otherNode: Node): Node;
+ removeNode(deep?: bool): Node;
+ replaceNode(replacement: Node): Node;
+}
+
+interface KeyboardEventExtensions {
+ keyCode: number;
+ which: number;
+ charCode: number;
+}
+
+interface History {
+ length: number;
+ back(distance?: any): void;
+ forward(distance?: any): void;
+ go(delta?: any): void;
+}
+declare var History: {
+ prototype: History;
+ new(): History;
+}
+
+interface DocumentStyle {
+ styleSheets: StyleSheetList;
+}
+
+interface SVGPathSegCurvetoCubicAbs extends SVGPathSeg {
+ y: number;
+ y1: number;
+ x2: number;
+ x: number;
+ x1: number;
+ y2: number;
+}
+declare var SVGPathSegCurvetoCubicAbs: {
+ prototype: SVGPathSegCurvetoCubicAbs;
+ new(): SVGPathSegCurvetoCubicAbs;
+}
+
+interface TimeRanges {
+ length: number;
+ start(index: number): number;
+ end(index: number): number;
+}
+declare var TimeRanges: {
+ prototype: TimeRanges;
+ new(): TimeRanges;
+}
+
+interface SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg {
+ y: number;
+ y1: number;
+ x: number;
+ x1: number;
+}
+declare var SVGPathSegCurvetoQuadraticAbs: {
+ prototype: SVGPathSegCurvetoQuadraticAbs;
+ new(): SVGPathSegCurvetoQuadraticAbs;
+}
+
+interface MSHTMLSelectElementExtensions {
+}
+
+interface CSSRule {
+ cssText: string;
+ parentStyleSheet: CSSStyleSheet;
+ parentRule: CSSRule;
+ type: number;
+ IMPORT_RULE: number;
+ MEDIA_RULE: number;
+ STYLE_RULE: number;
+ NAMESPACE_RULE: number;
+ PAGE_RULE: number;
+ UNKNOWN_RULE: number;
+ FONT_FACE_RULE: number;
+ CHARSET_RULE: number;
+}
+declare var CSSRule: {
+ prototype: CSSRule;
+ new(): CSSRule;
+ IMPORT_RULE: number;
+ MEDIA_RULE: number;
+ STYLE_RULE: number;
+ NAMESPACE_RULE: number;
+ PAGE_RULE: number;
+ UNKNOWN_RULE: number;
+ FONT_FACE_RULE: number;
+ CHARSET_RULE: number;
+}
+
+interface SVGPathSegLinetoAbs extends SVGPathSeg {
+ y: number;
+ x: number;
+}
+declare var SVGPathSegLinetoAbs: {
+ prototype: SVGPathSegLinetoAbs;
+ new(): SVGPathSegLinetoAbs;
+}
+
+interface MSMouseEventExtensions {
+ toElement: Element;
+ layerY: number;
+ fromElement: Element;
+ which: number;
+ layerX: number;
+}
+
+interface HTMLModElement extends HTMLElement, MSHTMLModElementExtensions {
+ dateTime: string;
+ cite: string;
+}
+declare var HTMLModElement: {
+ prototype: HTMLModElement;
+ new(): HTMLModElement;
+}
+
+interface DOML2DeprecatedWordWrapSuppression {
+ noWrap: bool;
+}
+
+interface BeforeUnloadEvent extends Event {
+ returnValue: string;
+}
+declare var BeforeUnloadEvent: {
+ prototype: BeforeUnloadEvent;
+ new(): BeforeUnloadEvent;
+}
+
+interface MSPopupWindow {
+ document: HTMLDocument;
+ isOpen: bool;
+ show(x: number, y: number, w: number, h: number, element?: any): void;
+ hide(): void;
+}
+declare var MSPopupWindow: {
+ prototype: MSPopupWindow;
+ new(): MSPopupWindow;
+}
+
+interface SVGMatrix {
+ e: number;
+ c: number;
+ a: number;
+ b: number;
+ d: number;
+ f: number;
+ multiply(secondMatrix: SVGMatrix): SVGMatrix;
+ flipY(): SVGMatrix;
+ skewY(angle: number): SVGMatrix;
+ inverse(): SVGMatrix;
+ scaleNonUniform(scaleFactorX: number, scaleFactorY: number): SVGMatrix;
+ rotate(angle: number): SVGMatrix;
+ flipX(): SVGMatrix;
+ translate(x: number, y: number): SVGMatrix;
+ scale(scaleFactor: number): SVGMatrix;
+ rotateFromVector(x: number, y: number): SVGMatrix;
+ skewX(angle: number): SVGMatrix;
+}
+declare var SVGMatrix: {
+ prototype: SVGMatrix;
+ new(): SVGMatrix;
+}
+
+interface SVGUseElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGURIReference {
+ y: SVGAnimatedLength;
+ width: SVGAnimatedLength;
+ animatedInstanceRoot: SVGElementInstance;
+ instanceRoot: SVGElementInstance;
+ x: SVGAnimatedLength;
+ height: SVGAnimatedLength;
+}
+declare var SVGUseElement: {
+ prototype: SVGUseElement;
+ new(): SVGUseElement;
+}
+
+interface Event extends MSEventExtensions {
+ timeStamp: number;
+ defaultPrevented: bool;
+ isTrusted: bool;
+ currentTarget: EventTarget;
+ target: EventTarget;
+ eventPhase: number;
+ type: string;
+ cancelable: bool;
+ bubbles: bool;
+ initEvent(eventTypeArg: string, canBubbleArg: bool, cancelableArg: bool): void;
+ stopPropagation(): void;
+ stopImmediatePropagation(): void;
+ preventDefault(): void;
+ CAPTURING_PHASE: number;
+ AT_TARGET: number;
+ BUBBLING_PHASE: number;
+}
+declare var Event: {
+ prototype: Event;
+ new(): Event;
+ CAPTURING_PHASE: number;
+ AT_TARGET: number;
+ BUBBLING_PHASE: number;
+}
+
+interface ImageData {
+ width: number;
+ data: number[];
+ height: number;
+}
+declare var ImageData: {
+ prototype: ImageData;
+ new(): ImageData;
+}
+
+interface MSHTMLElementExtensions {
+ onlosecapture: (ev: MSEventObj) => any;
+ onrowexit: (ev: MSEventObj) => any;
+ oncontrolselect: (ev: MSEventObj) => any;
+ onrowsinserted: (ev: MSEventObj) => any;
+ onmouseleave: (ev: MouseEvent) => any;
+ document: HTMLDocument;
+ behaviorUrns: MSBehaviorUrnsCollection;
+ onpropertychange: (ev: MSEventObj) => any;
+ children: HTMLCollection;
+ filters: Object;
+ onbeforecut: (ev: DragEvent) => any;
+ scopeName: string;
+ onbeforepaste: (ev: DragEvent) => any;
+ onmove: (ev: MSEventObj) => any;
+ onafterupdate: (ev: MSEventObj) => any;
+ onbeforecopy: (ev: DragEvent) => any;
+ onlayoutcomplete: (ev: MSEventObj) => any;
+ onresizeend: (ev: MSEventObj) => any;
+ uniqueID: string;
+ onhelp: (ev: Event) => any;
+ onbeforeactivate: (ev: UIEvent) => any;
+ isMultiLine: bool;
+ uniqueNumber: number;
+ tagUrn: string;
+ onfocusout: (ev: FocusEvent) => any;
+ ondataavailable: (ev: MSEventObj) => any;
+ hideFocus: bool;
+ onbeforeupdate: (ev: MSEventObj) => any;
+ onfilterchange: (ev: MSEventObj) => any;
+ onfocusin: (ev: FocusEvent) => any;
+ recordNumber: any;
+ parentTextEdit: Element;
+ ondatasetcomplete: (ev: MSEventObj) => any;
+ onbeforedeactivate: (ev: UIEvent) => any;
+ outerText: string;
+ onresizestart: (ev: MSEventObj) => any;
+ onactivate: (ev: UIEvent) => any;
+ isTextEdit: bool;
+ isDisabled: bool;
+ readyState: string;
+ all: HTMLCollection;
+ onmouseenter: (ev: MouseEvent) => any;
+ onmovestart: (ev: MSEventObj) => any;
+ onselectstart: (ev: Event) => any;
+ onpaste: (ev: DragEvent) => any;
+ canHaveHTML: bool;
+ innerText: string;
+ onerrorupdate: (ev: MSEventObj) => any;
+ ondeactivate: (ev: UIEvent) => any;
+ oncut: (ev: DragEvent) => any;
+ onmoveend: (ev: MSEventObj) => any;
+ onresize: (ev: UIEvent) => any;
+ language: string;
+ ondatasetchanged: (ev: MSEventObj) => any;
+ oncopy: (ev: DragEvent) => any;
+ onrowsdelete: (ev: MSEventObj) => any;
+ parentElement: HTMLElement;
+ onrowenter: (ev: MSEventObj) => any;
+ onbeforeeditfocus: (ev: MSEventObj) => any;
+ canHaveChildren: bool;
+ sourceIndex: number;
+ oncellchange: (ev: MSEventObj) => any;
+ dragDrop(): bool;
+ releaseCapture(): void;
+ addFilter(filter: Object): void;
+ setCapture(containerCapture?: bool): void;
+ removeBehavior(cookie: number): bool;
+ contains(child: HTMLElement): bool;
+ applyElement(apply: Element, where?: string): Element;
+ replaceAdjacentText(where: string, newText: string): string;
+ mergeAttributes(source: HTMLElement, preserveIdentity?: bool): void;
+ insertAdjacentElement(position: string, insertedElement: Element): Element;
+ insertAdjacentText(where: string, text: string): void;
+ getAdjacentText(where: string): string;
+ removeFilter(filter: Object): void;
+ setActive(): void;
+ addBehavior(bstrUrl: string, factory?: any): number;
+ clearAttributes(): void;
+}
+
+interface HTMLTableColElement extends HTMLElement, MSHTMLTableColElementExtensions, HTMLTableAlignment, DOML2DeprecatedAlignmentStyle_HTMLTableColElement {
+ width: any;
+ span: number;
+}
+declare var HTMLTableColElement: {
+ prototype: HTMLTableColElement;
+ new(): HTMLTableColElement;
+}
+
+interface HTMLDocument extends MSEventAttachmentTarget, MSHTMLDocumentSelection, MSHTMLDocumentExtensions, MSNodeExtensions, MSResourceMetadata, MSHTMLDocumentEventExtensions, MSHTMLDocumentViewExtensions {
+ ondragend: (ev: DragEvent) => any;
+ ondragover: (ev: DragEvent) => any;
+ onkeydown: (ev: KeyboardEvent) => any;
+ bgColor: string;
+ onkeyup: (ev: KeyboardEvent) => any;
+ onreset: (ev: Event) => any;
+ onmouseup: (ev: MouseEvent) => any;
+ ondragstart: (ev: DragEvent) => any;
+ scripts: HTMLCollection;
+ ondrag: (ev: DragEvent) => any;
+ linkColor: string;
+ ondragleave: (ev: DragEvent) => any;
+ onmouseover: (ev: MouseEvent) => any;
+ onpause: (ev: Event) => any;
+ charset: string;
+ vlinkColor: string;
+ onmousedown: (ev: MouseEvent) => any;
+ onseeked: (ev: Event) => any;
+ title: string;
+ onclick: (ev: MouseEvent) => any;
+ onwaiting: (ev: Event) => any;
+ defaultCharset: string;
+ embeds: HTMLCollection;
+ ondurationchange: (ev: Event) => any;
+ all: HTMLCollection;
+ applets: HTMLCollection;
+ forms: HTMLCollection;
+ onblur: (ev: FocusEvent) => any;
+ dir: string;
+ body: HTMLElement;
+ designMode: string;
+ onemptied: (ev: Event) => any;
+ domain: string;
+ onseeking: (ev: Event) => any;
+ oncanplay: (ev: Event) => any;
+ onstalled: (ev: Event) => any;
+ onmousemove: (ev: MouseEvent) => any;
+ onratechange: (ev: Event) => any;
+ onloadstart: (ev: Event) => any;
+ ondragenter: (ev: DragEvent) => any;
+ onsubmit: (ev: Event) => any;
+ onprogress: (ev: any) => any;
+ ondblclick: (ev: MouseEvent) => any;
+ oncontextmenu: (ev: MouseEvent) => any;
+ activeElement: Element;
+ onchange: (ev: Event) => any;
+ onloadedmetadata: (ev: Event) => any;
+ onerror: (ev: Event) => any;
+ onplay: (ev: Event) => any;
+ links: HTMLCollection;
+ onplaying: (ev: Event) => any;
+ URL: string;
+ images: HTMLCollection;
+ head: HTMLHeadElement;
+ location: Location;
+ cookie: string;
+ oncanplaythrough: (ev: Event) => any;
+ onabort: (ev: UIEvent) => any;
+ characterSet: string;
+ anchors: HTMLCollection;
+ lastModified: string;
+ onreadystatechange: (ev: Event) => any;
+ onkeypress: (ev: KeyboardEvent) => any;
+ onloadeddata: (ev: Event) => any;
+ plugins: HTMLCollection;
+ onsuspend: (ev: Event) => any;
+ referrer: string;
+ readyState: string;
+ alinkColor: string;
+ onfocus: (ev: FocusEvent) => any;
+ fgColor: string;
+ ontimeupdate: (ev: Event) => any;
+ onselect: (ev: UIEvent) => any;
+ ondrop: (ev: DragEvent) => any;
+ onmouseout: (ev: MouseEvent) => any;
+ onended: (ev: Event) => any;
+ compatMode: string;
+ onscroll: (ev: UIEvent) => any;
+ onmousewheel: (ev: MouseWheelEvent) => any;
+ onload: (ev: Event) => any;
+ onvolumechange: (ev: Event) => any;
+ oninput: (ev: Event) => any;
+ queryCommandValue(commandId: string): string;
+ queryCommandIndeterm(commandId: string): bool;
+ execCommand(commandId: string, showUI?: bool, value?: any): bool;
+ getElementsByName(elementName: string): NodeList;
+ writeln(...content: string[]): void;
+ open(url?: string, name?: string, features?: string, replace?: bool): any;
+ queryCommandState(commandId: string): bool;
+ close(): void;
+ hasFocus(): bool;
+ getElementsByClassName(classNames: string): NodeList;
+ queryCommandSupported(commandId: string): bool;
+ getSelection(): Selection;
+ queryCommandEnabled(commandId: string): bool;
+ write(...content: string[]): void;
+ queryCommandText(commandId: string): string;
+}
+
+interface SVGException {
+ code: number;
+ message: string;
+ toString(): string;
+ SVG_MATRIX_NOT_INVERTABLE: number;
+ SVG_WRONG_TYPE_ERR: number;
+ SVG_INVALID_VALUE_ERR: number;
+}
+declare var SVGException: {
+ prototype: SVGException;
+ new(): SVGException;
+ SVG_MATRIX_NOT_INVERTABLE: number;
+ SVG_WRONG_TYPE_ERR: number;
+ SVG_INVALID_VALUE_ERR: number;
+}
+
+interface DOML2DeprecatedTableCellHeight {
+ height: any;
+}
+
+interface HTMLTableAlignment {
+ ch: string;
+ vAlign: string;
+ chOff: string;
+}
+
+interface SVGAnimatedEnumeration {
+ animVal: number;
+ baseVal: number;
+}
+declare var SVGAnimatedEnumeration: {
+ prototype: SVGAnimatedEnumeration;
+ new(): SVGAnimatedEnumeration;
+}
+
+interface SVGLinearGradientElement extends SVGGradientElement {
+ y1: SVGAnimatedLength;
+ x2: SVGAnimatedLength;
+ x1: SVGAnimatedLength;
+ y2: SVGAnimatedLength;
+}
+declare var SVGLinearGradientElement: {
+ prototype: SVGLinearGradientElement;
+ new(): SVGLinearGradientElement;
+}
+
+interface DOML2DeprecatedSizeProperty {
+ size: number;
+}
+
+interface MSHTMLHeadingElementExtensions extends DOML2DeprecatedTextFlowControl_HTMLBlockElement {
+}
+
+interface MSBorderColorStyle_HTMLTableCellElement {
+ borderColor: any;
+}
+
+interface DOML2DeprecatedWidthStyle_HTMLHRElement {
+ width: number;
+}
+
+interface HTMLUListElement extends HTMLElement, DOML2DeprecatedListSpaceReduction, DOML2DeprecatedListNumberingAndBulletStyle, MSHTMLUListElementExtensions {
+}
+declare var HTMLUListElement: {
+ prototype: HTMLUListElement;
+ new(): HTMLUListElement;
+}
+
+interface SVGRectElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests {
+ y: SVGAnimatedLength;
+ width: SVGAnimatedLength;
+ ry: SVGAnimatedLength;
+ rx: SVGAnimatedLength;
+ x: SVGAnimatedLength;
+ height: SVGAnimatedLength;
+}
+declare var SVGRectElement: {
+ prototype: SVGRectElement;
+ new(): SVGRectElement;
+}
+
+interface DOML2DeprecatedBorderStyle {
+ border: string;
+}
+
+interface HTMLDivElement extends HTMLElement, DOML2DeprecatedAlignmentStyle_HTMLDivElement, MSHTMLDivElementExtensions, MSDataBindingExtensions {
+}
+declare var HTMLDivElement: {
+ prototype: HTMLDivElement;
+ new(): HTMLDivElement;
+}
+
+interface NavigatorDoNotTrack {
+ msDoNotTrack: string;
+}
+
+interface SVG1_1Properties {
+ fillRule: string;
+ strokeLinecap: string;
+ stopColor: string;
+ glyphOrientationHorizontal: string;
+ kerning: string;
+ alignmentBaseline: string;
+ dominantBaseline: string;
+ fill: string;
+ strokeMiterlimit: string;
+ marker: string;
+ glyphOrientationVertical: string;
+ markerMid: string;
+ textAnchor: string;
+ fillOpacity: string;
+ strokeDasharray: string;
+ mask: string;
+ stopOpacity: string;
+ stroke: string;
+ strokeDashoffset: string;
+ strokeOpacity: string;
+ markerStart: string;
+ pointerEvents: string;
+ baselineShift: string;
+ markerEnd: string;
+ clipRule: string;
+ strokeLinejoin: string;
+ clipPath: string;
+ strokeWidth: string;
+}
+
+interface NamedNodeMap {
+ length: number;
+ removeNamedItemNS(namespaceURI: string, localName: string): Node;
+ item(index: number): Node;
+ [index: number]: Node;
+ removeNamedItem(name: string): Node;
+ getNamedItem(name: string): Node;
+ [name: string]: Node;
+ setNamedItem(arg: Node): Node;
+ getNamedItemNS(namespaceURI: string, localName: string): Node;
+ setNamedItemNS(arg: Node): Node;
+}
+declare var NamedNodeMap: {
+ prototype: NamedNodeMap;
+ new(): NamedNodeMap;
+}
+
+interface MediaList {
+ length: number;
+ mediaText: string;
+ deleteMedium(oldMedium: string): void;
+ appendMedium(newMedium: string): void;
+ item(index: number): string;
+ [index: number]: string;
+ toString(): string;
+}
+declare var MediaList: {
+ prototype: MediaList;
+ new(): MediaList;
+}
+
+interface SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg {
+ y: number;
+ x: number;
+}
+declare var SVGPathSegCurvetoQuadraticSmoothAbs: {
+ prototype: SVGPathSegCurvetoQuadraticSmoothAbs;
+ new(): SVGPathSegCurvetoQuadraticSmoothAbs;
+}
+
+interface SVGLengthList {
+ numberOfItems: number;
+ replaceItem(newItem: SVGLength, index: number): SVGLength;
+ getItem(index: number): SVGLength;
+ clear(): void;
+ appendItem(newItem: SVGLength): SVGLength;
+ initialize(newItem: SVGLength): SVGLength;
+ removeItem(index: number): SVGLength;
+ insertItemBefore(newItem: SVGLength, index: number): SVGLength;
+}
+declare var SVGLengthList: {
+ prototype: SVGLengthList;
+ new(): SVGLengthList;
+}
+
+interface SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg {
+ y: number;
+ x2: number;
+ x: number;
+ y2: number;
+}
+declare var SVGPathSegCurvetoCubicSmoothRel: {
+ prototype: SVGPathSegCurvetoCubicSmoothRel;
+ new(): SVGPathSegCurvetoCubicSmoothRel;
+}
+
+interface MSWindowExtensions {
+ status: string;
+ onmouseleave: (ev: MouseEvent) => any;
+ screenLeft: number;
+ offscreenBuffering: any;
+ maxConnectionsPerServer: number;
+ onmouseenter: (ev: MouseEvent) => any;
+ clipboardData: DataTransfer;
+ defaultStatus: string;
+ clientInformation: Navigator;
+ closed: bool;
+ onhelp: (ev: Event) => any;
+ external: BrowserPublic;
+ event: MSEventObj;
+ onfocusout: (ev: FocusEvent) => any;
+ screenTop: number;
+ onfocusin: (ev: FocusEvent) => any;
+ showModelessDialog(url?: string, argument?: any, options?: any): Window;
+ navigate(url: string): void;
+ resizeBy(x?: number, y?: number): void;
+ item(index: any): any;
+ resizeTo(x?: number, y?: number): void;
+ createPopup(arguments?: any): MSPopupWindow;
+ toStaticHTML(html: string): string;
+ execScript(code: string, language?: string): any;
+ msWriteProfilerMark(profilerMarkName: string): void;
+ moveTo(x?: number, y?: number): void;
+ moveBy(x?: number, y?: number): void;
+ showHelp(url: string, helpArg?: any, features?: string): void;
+}
+
+interface ProcessingInstruction extends Node {
+ target: string;
+ data: string;
+}
+declare var ProcessingInstruction: {
+ prototype: ProcessingInstruction;
+ new(): ProcessingInstruction;
+}
+
+interface MSBehaviorUrnsCollection {
+ length: number;
+ item(index: number): string;
+}
+declare var MSBehaviorUrnsCollection: {
+ prototype: MSBehaviorUrnsCollection;
+ new(): MSBehaviorUrnsCollection;
+}
+
+interface CSSFontFaceRule extends CSSRule {
+ style: CSSStyleDeclaration;
+}
+declare var CSSFontFaceRule: {
+ prototype: CSSFontFaceRule;
+ new(): CSSFontFaceRule;
+}
+
+interface DOML2DeprecatedBackgroundStyle {
+ background: string;
+}
+
+interface TextEvent extends UIEvent {
+ inputMethod: number;
+ data: string;
+ locale: string;
+ initTextEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, dataArg: string, inputMethod: number, locale: string): void;
+ DOM_INPUT_METHOD_KEYBOARD: number;
+ DOM_INPUT_METHOD_DROP: number;
+ DOM_INPUT_METHOD_IME: number;
+ DOM_INPUT_METHOD_SCRIPT: number;
+ DOM_INPUT_METHOD_VOICE: number;
+ DOM_INPUT_METHOD_UNKNOWN: number;
+ DOM_INPUT_METHOD_PASTE: number;
+ DOM_INPUT_METHOD_HANDWRITING: number;
+ DOM_INPUT_METHOD_OPTION: number;
+ DOM_INPUT_METHOD_MULTIMODAL: number;
+}
+declare var TextEvent: {
+ prototype: TextEvent;
+ new(): TextEvent;
+ DOM_INPUT_METHOD_KEYBOARD: number;
+ DOM_INPUT_METHOD_DROP: number;
+ DOM_INPUT_METHOD_IME: number;
+ DOM_INPUT_METHOD_SCRIPT: number;
+ DOM_INPUT_METHOD_VOICE: number;
+ DOM_INPUT_METHOD_UNKNOWN: number;
+ DOM_INPUT_METHOD_PASTE: number;
+ DOM_INPUT_METHOD_HANDWRITING: number;
+ DOM_INPUT_METHOD_OPTION: number;
+ DOM_INPUT_METHOD_MULTIMODAL: number;
+}
+
+interface MSHTMLHRElementExtensions extends DOML2DeprecatedColorProperty {
+}
+
+interface AbstractView {
+ styleMedia: StyleMedia;
+ document: Document;
+}
+
+interface DocumentFragment extends Node, NodeSelector, MSEventAttachmentTarget, MSNodeExtensions {
+}
+declare var DocumentFragment: {
+ prototype: DocumentFragment;
+ new(): DocumentFragment;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLFieldSetElement {
+ align: string;
+}
+
+interface SVGPolylineElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGAnimatedPoints, SVGTests {
+}
+declare var SVGPolylineElement: {
+ prototype: SVGPolylineElement;
+ new(): SVGPolylineElement;
+}
+
+interface DOML2DeprecatedWidthStyle {
+ width: number;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLHeadingElement {
+ align: string;
+}
+
+interface SVGAnimatedPathData {
+ pathSegList: SVGPathSegList;
+}
+
+interface Position {
+ timestamp: Date;
+ coords: Coordinates;
+}
+declare var Position: {
+ prototype: Position;
+ new(): Position;
+}
+
+interface BookmarkCollection {
+ length: number;
+ item(index: number): any;
+ [index: number]: any;
+}
+declare var BookmarkCollection: {
+ prototype: BookmarkCollection;
+ new(): BookmarkCollection;
+}
+
+interface CSSPageRule extends CSSRule, StyleSheetPage {
+ selectorText: string;
+ style: CSSStyleDeclaration;
+}
+declare var CSSPageRule: {
+ prototype: CSSPageRule;
+ new(): CSSPageRule;
+}
+
+interface WindowPerformance {
+ performance: any;
+}
+
+interface HTMLBRElement extends HTMLElement, DOML2DeprecatedTextFlowControl_HTMLBRElement {
+}
+declare var HTMLBRElement: {
+ prototype: HTMLBRElement;
+ new(): HTMLBRElement;
+}
+
+interface MSHTMLDivElementExtensions extends DOML2DeprecatedWordWrapSuppression_HTMLDivElement {
+}
+
+interface DOML2DeprecatedBorderStyle_HTMLInputElement {
+ border: string;
+}
+
+interface HTMLSpanElement extends HTMLElement, MSHTMLSpanElementExtensions, MSDataBindingExtensions {
+}
+declare var HTMLSpanElement: {
+ prototype: HTMLSpanElement;
+ new(): HTMLSpanElement;
+}
+
+interface HTMLHRElementDOML2Deprecated {
+ noShade: bool;
+}
+
+interface HTMLHeadElement extends HTMLElement {
+ profile: string;
+}
+declare var HTMLHeadElement: {
+ prototype: HTMLHeadElement;
+ new(): HTMLHeadElement;
+}
+
+interface NodeFilterCallback {
+ (...args: any[]): any;
+}
+
+interface HTMLHeadingElement extends HTMLElement, DOML2DeprecatedAlignmentStyle_HTMLHeadingElement, MSHTMLHeadingElementExtensions {
+}
+declare var HTMLHeadingElement: {
+ prototype: HTMLHeadingElement;
+ new(): HTMLHeadingElement;
+}
+
+interface HTMLFormElement extends HTMLElement, MSHTMLFormElementExtensions, MSHTMLCollectionExtensions {
+ length: number;
+ target: string;
+ acceptCharset: string;
+ enctype: string;
+ elements: HTMLCollection;
+ action: string;
+ name: string;
+ method: string;
+ reset(): void;
+ item(name?: any, index?: any): any;
+ (name: any, index: any): any;
+ submit(): void;
+ namedItem(name: string): any;
+ [name: string]: any;
+ (name: string): any;
+}
+declare var HTMLFormElement: {
+ prototype: HTMLFormElement;
+ new(): HTMLFormElement;
+}
+
+interface SVGZoomAndPan {
+ zoomAndPan: number;
+ SVG_ZOOMANDPAN_MAGNIFY: number;
+ SVG_ZOOMANDPAN_UNKNOWN: number;
+ SVG_ZOOMANDPAN_DISABLE: number;
+}
+declare var SVGZoomAndPan: {
+ prototype: SVGZoomAndPan;
+ new(): SVGZoomAndPan;
+ SVG_ZOOMANDPAN_MAGNIFY: number;
+ SVG_ZOOMANDPAN_UNKNOWN: number;
+ SVG_ZOOMANDPAN_DISABLE: number;
+}
+
+interface MSEventExtensions {
+ cancelBubble: bool;
+ srcElement: Element;
+}
+
+interface HTMLMediaElement extends HTMLElement {
+ initialTime: number;
+ played: TimeRanges;
+ currentSrc: string;
+ readyState: string;
+ autobuffer: bool;
+ loop: bool;
+ ended: bool;
+ buffered: TimeRanges;
+ error: MediaError;
+ seekable: TimeRanges;
+ autoplay: bool;
+ controls: bool;
+ volume: number;
+ src: string;
+ playbackRate: number;
+ duration: number;
+ muted: bool;
+ defaultPlaybackRate: number;
+ paused: bool;
+ seeking: bool;
+ currentTime: number;
+ preload: string;
+ networkState: number;
+ pause(): void;
+ play(): void;
+ load(): void;
+ canPlayType(type: string): string;
+ HAVE_METADATA: number;
+ HAVE_CURRENT_DATA: number;
+ HAVE_NOTHING: number;
+ NETWORK_NO_SOURCE: number;
+ HAVE_ENOUGH_DATA: number;
+ NETWORK_EMPTY: number;
+ NETWORK_LOADING: number;
+ NETWORK_IDLE: number;
+ HAVE_FUTURE_DATA: number;
+}
+declare var HTMLMediaElement: {
+ prototype: HTMLMediaElement;
+ new(): HTMLMediaElement;
+ HAVE_METADATA: number;
+ HAVE_CURRENT_DATA: number;
+ HAVE_NOTHING: number;
+ NETWORK_NO_SOURCE: number;
+ HAVE_ENOUGH_DATA: number;
+ NETWORK_EMPTY: number;
+ NETWORK_LOADING: number;
+ NETWORK_IDLE: number;
+ HAVE_FUTURE_DATA: number;
+}
+
+interface ElementCSSInlineStyle extends MSElementCSSInlineStyleExtensions {
+ runtimeStyle: MSStyleCSSProperties;
+ currentStyle: MSCurrentStyleCSSProperties;
+}
+
+interface DOMParser {
+ parseFromString(source: string, mimeType: string): Document;
+}
+declare var DOMParser: {
+ prototype: DOMParser;
+ new (): DOMParser;
+}
+
+interface MSMimeTypesCollection {
+ length: number;
+}
+declare var MSMimeTypesCollection: {
+ prototype: MSMimeTypesCollection;
+ new(): MSMimeTypesCollection;
+}
+
+interface StyleSheet {
+ disabled: bool;
+ ownerNode: Node;
+ parentStyleSheet: StyleSheet;
+ href: string;
+ media: MediaList;
+ type: string;
+ title: string;
+}
+declare var StyleSheet: {
+ prototype: StyleSheet;
+ new(): StyleSheet;
+}
+
+interface DOML2DeprecatedBorderStyle_HTMLTableElement {
+ border: string;
+}
+
+interface DOML2DeprecatedWidthStyle_HTMLAppletElement {
+ width: number;
+}
+
+interface SVGTextPathElement extends SVGTextContentElement, SVGURIReference {
+ startOffset: SVGAnimatedLength;
+ method: SVGAnimatedEnumeration;
+ spacing: SVGAnimatedEnumeration;
+ TEXTPATH_SPACINGTYPE_EXACT: number;
+ TEXTPATH_METHODTYPE_STRETCH: number;
+ TEXTPATH_SPACINGTYPE_AUTO: number;
+ TEXTPATH_SPACINGTYPE_UNKNOWN: number;
+ TEXTPATH_METHODTYPE_UNKNOWN: number;
+ TEXTPATH_METHODTYPE_ALIGN: number;
+}
+declare var SVGTextPathElement: {
+ prototype: SVGTextPathElement;
+ new(): SVGTextPathElement;
+ TEXTPATH_SPACINGTYPE_EXACT: number;
+ TEXTPATH_METHODTYPE_STRETCH: number;
+ TEXTPATH_SPACINGTYPE_AUTO: number;
+ TEXTPATH_SPACINGTYPE_UNKNOWN: number;
+ TEXTPATH_METHODTYPE_UNKNOWN: number;
+ TEXTPATH_METHODTYPE_ALIGN: number;
+}
+
+interface NodeList {
+ length: number;
+ item(index: number): Node;
+ [index: number]: Node;
+}
+declare var NodeList: {
+ prototype: NodeList;
+ new(): NodeList;
+}
+
+interface HTMLDTElement extends HTMLElement, DOML2DeprecatedWordWrapSuppression_HTMLDTElement {
+}
+declare var HTMLDTElement: {
+ prototype: HTMLDTElement;
+ new(): HTMLDTElement;
+}
+
+interface XMLSerializer {
+ serializeToString(target: Node): string;
+}
+declare var XMLSerializer: {
+ prototype: XMLSerializer;
+ new (): XMLSerializer;
+}
+
+interface StyleSheetPage {
+ pseudoClass: string;
+ selector: string;
+}
+
+interface DOML2DeprecatedWordWrapSuppression_HTMLDDElement {
+ noWrap: bool;
+}
+
+interface MSHTMLTableRowElementExtensions {
+ height: any;
+}
+
+interface SVGGradientElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGURIReference {
+ spreadMethod: SVGAnimatedEnumeration;
+ gradientTransform: SVGAnimatedTransformList;
+ gradientUnits: SVGAnimatedEnumeration;
+ SVG_SPREADMETHOD_REFLECT: number;
+ SVG_SPREADMETHOD_PAD: number;
+ SVG_SPREADMETHOD_UNKNOWN: number;
+ SVG_SPREADMETHOD_REPEAT: number;
+}
+declare var SVGGradientElement: {
+ prototype: SVGGradientElement;
+ new(): SVGGradientElement;
+ SVG_SPREADMETHOD_REFLECT: number;
+ SVG_SPREADMETHOD_PAD: number;
+ SVG_SPREADMETHOD_UNKNOWN: number;
+ SVG_SPREADMETHOD_REPEAT: number;
+}
+
+interface DOML2DeprecatedTextFlowControl_HTMLBRElement {
+ clear: string;
+}
+
+interface MSHTMLParagraphElementExtensions extends DOML2DeprecatedTextFlowControl_HTMLBlockElement {
+}
+
+interface NodeFilter {
+ acceptNode(n: Node): number;
+ SHOW_ENTITY_REFERENCE: number;
+ SHOW_NOTATION: number;
+ SHOW_ENTITY: number;
+ SHOW_DOCUMENT: number;
+ SHOW_PROCESSING_INSTRUCTION: number;
+ FILTER_REJECT: number;
+ SHOW_CDATA_SECTION: number;
+ FILTER_ACCEPT: number;
+ SHOW_ALL: number;
+ SHOW_DOCUMENT_TYPE: number;
+ SHOW_TEXT: number;
+ SHOW_ELEMENT: number;
+ SHOW_COMMENT: number;
+ FILTER_SKIP: number;
+ SHOW_ATTRIBUTE: number;
+ SHOW_DOCUMENT_FRAGMENT: number;
+}
+declare var NodeFilter: {
+ prototype: NodeFilter;
+ new(): NodeFilter;
+ SHOW_ENTITY_REFERENCE: number;
+ SHOW_NOTATION: number;
+ SHOW_ENTITY: number;
+ SHOW_DOCUMENT: number;
+ SHOW_PROCESSING_INSTRUCTION: number;
+ FILTER_REJECT: number;
+ SHOW_CDATA_SECTION: number;
+ FILTER_ACCEPT: number;
+ SHOW_ALL: number;
+ SHOW_DOCUMENT_TYPE: number;
+ SHOW_TEXT: number;
+ SHOW_ELEMENT: number;
+ SHOW_COMMENT: number;
+ FILTER_SKIP: number;
+ SHOW_ATTRIBUTE: number;
+ SHOW_DOCUMENT_FRAGMENT: number;
+}
+
+interface MSBorderColorStyle_HTMLFrameElement {
+ borderColor: any;
+}
+
+interface MSHTMLOListElementExtensions {
+}
+
+interface DOML2DeprecatedWordWrapSuppression_HTMLDTElement {
+ noWrap: bool;
+}
+
+interface ScreenView extends AbstractView {
+ outerWidth: number;
+ pageXOffset: number;
+ innerWidth: number;
+ pageYOffset: number;
+ screenY: number;
+ outerHeight: number;
+ screen: Screen;
+ innerHeight: number;
+ screenX: number;
+ scroll(x?: number, y?: number): void;
+ scrollBy(x?: number, y?: number): void;
+ scrollTo(x?: number, y?: number): void;
+}
+
+interface DOML2DeprecatedMarginStyle_HTMLObjectElement {
+ vspace: number;
+ hspace: number;
+}
+
+interface DOML2DeprecatedMarginStyle_HTMLInputElement {
+ vspace: number;
+ hspace: number;
+}
+
+interface MSHTMLTableSectionElementExtensions extends DOML2DeprecatedBackgroundColorStyle {
+ moveRow(indexFrom?: number, indexTo?: number): Object;
+}
+
+interface HTMLFieldSetElement extends HTMLElement, MSHTMLFieldSetElementExtensions {
+ form: HTMLFormElement;
+}
+declare var HTMLFieldSetElement: {
+ prototype: HTMLFieldSetElement;
+ new(): HTMLFieldSetElement;
+}
+
+interface MediaError {
+ code: number;
+ MEDIA_ERR_ABORTED: number;
+ MEDIA_ERR_NETWORK: number;
+ MEDIA_ERR_SRC_NOT_SUPPORTED: number;
+ MEDIA_ERR_DECODE: number;
+}
+declare var MediaError: {
+ prototype: MediaError;
+ new(): MediaError;
+ MEDIA_ERR_ABORTED: number;
+ MEDIA_ERR_NETWORK: number;
+ MEDIA_ERR_SRC_NOT_SUPPORTED: number;
+ MEDIA_ERR_DECODE: number;
+}
+
+interface SVGNumberList {
+ numberOfItems: number;
+ replaceItem(newItem: SVGNumber, index: number): SVGNumber;
+ getItem(index: number): SVGNumber;
+ clear(): void;
+ appendItem(newItem: SVGNumber): SVGNumber;
+ initialize(newItem: SVGNumber): SVGNumber;
+ removeItem(index: number): SVGNumber;
+ insertItemBefore(newItem: SVGNumber, index: number): SVGNumber;
+}
+declare var SVGNumberList: {
+ prototype: SVGNumberList;
+ new(): SVGNumberList;
+}
+
+interface HTMLBGSoundElement extends HTMLElement {
+ balance: any;
+ volume: any;
+ src: string;
+ loop: number;
+}
+declare var HTMLBGSoundElement: {
+ prototype: HTMLBGSoundElement;
+ new(): HTMLBGSoundElement;
+}
+
+interface HTMLElement extends Element, MSHTMLElementRangeExtensions, ElementCSSInlineStyle, MSEventAttachmentTarget, MSHTMLElementExtensions, MSNodeExtensions {
+ ondragend: (ev: DragEvent) => any;
+ onkeydown: (ev: KeyboardEvent) => any;
+ ondragover: (ev: DragEvent) => any;
+ onkeyup: (ev: KeyboardEvent) => any;
+ offsetTop: number;
+ onreset: (ev: Event) => any;
+ onmouseup: (ev: MouseEvent) => any;
+ ondragstart: (ev: DragEvent) => any;
+ ondrag: (ev: DragEvent) => any;
+ innerHTML: string;
+ onmouseover: (ev: MouseEvent) => any;
+ ondragleave: (ev: DragEvent) => any;
+ lang: string;
+ onpause: (ev: Event) => any;
+ className: string;
+ onseeked: (ev: Event) => any;
+ onmousedown: (ev: MouseEvent) => any;
+ title: string;
+ onclick: (ev: MouseEvent) => any;
+ onwaiting: (ev: Event) => any;
+ outerHTML: string;
+ offsetLeft: number;
+ ondurationchange: (ev: Event) => any;
+ offsetHeight: number;
+ dir: string;
+ onblur: (ev: FocusEvent) => any;
+ onemptied: (ev: Event) => any;
+ onseeking: (ev: Event) => any;
+ oncanplay: (ev: Event) => any;
+ onstalled: (ev: Event) => any;
+ onmousemove: (ev: MouseEvent) => any;
+ style: MSStyleCSSProperties;
+ isContentEditable: bool;
+ onratechange: (ev: Event) => any;
+ onloadstart: (ev: Event) => any;
+ ondragenter: (ev: DragEvent) => any;
+ contentEditable: string;
+ onsubmit: (ev: Event) => any;
+ tabIndex: number;
+ onprogress: (ev: any) => any;
+ ondblclick: (ev: MouseEvent) => any;
+ oncontextmenu: (ev: MouseEvent) => any;
+ onchange: (ev: Event) => any;
+ onloadedmetadata: (ev: Event) => any;
+ onerror: (ev: Event) => any;
+ onplay: (ev: Event) => any;
+ id: string;
+ onplaying: (ev: Event) => any;
+ oncanplaythrough: (ev: Event) => any;
+ onabort: (ev: UIEvent) => any;
+ onreadystatechange: (ev: Event) => any;
+ onkeypress: (ev: KeyboardEvent) => any;
+ offsetParent: Element;
+ onloadeddata: (ev: Event) => any;
+ disabled: bool;
+ onsuspend: (ev: Event) => any;
+ accessKey: string;
+ onfocus: (ev: FocusEvent) => any;
+ ontimeupdate: (ev: Event) => any;
+ onselect: (ev: UIEvent) => any;
+ ondrop: (ev: DragEvent) => any;
+ offsetWidth: number;
+ onmouseout: (ev: MouseEvent) => any;
+ onended: (ev: Event) => any;
+ onscroll: (ev: UIEvent) => any;
+ onmousewheel: (ev: MouseWheelEvent) => any;
+ onvolumechange: (ev: Event) => any;
+ onload: (ev: Event) => any;
+ oninput: (ev: Event) => any;
+ click(): void;
+ getElementsByClassName(classNames: string): NodeList;
+ scrollIntoView(top?: bool): void;
+ focus(): void;
+ blur(): void;
+ insertAdjacentHTML(where: string, html: string): void;
+}
+declare var HTMLElement: {
+ prototype: HTMLElement;
+ new(): HTMLElement;
+}
+
+interface Comment extends CharacterData, MSCommentExtensions {
+}
+declare var Comment: {
+ prototype: Comment;
+ new(): Comment;
+}
+
+interface CanvasPattern {
+}
+declare var CanvasPattern: {
+ prototype: CanvasPattern;
+ new(): CanvasPattern;
+}
+
+interface HTMLHRElement extends HTMLElement, DOML2DeprecatedWidthStyle_HTMLHRElement, MSHTMLHRElementExtensions, HTMLHRElementDOML2Deprecated, DOML2DeprecatedAlignmentStyle_HTMLHRElement, DOML2DeprecatedSizeProperty {
+}
+declare var HTMLHRElement: {
+ prototype: HTMLHRElement;
+ new(): HTMLHRElement;
+}
+
+interface MSHTMLFrameSetElementExtensions {
+ name: string;
+ frameBorder: string;
+ border: string;
+ frameSpacing: any;
+}
+
+interface DOML2DeprecatedTextFlowControl_HTMLBlockElement {
+ clear: string;
+}
+
+interface PositionOptions {
+ enableHighAccuracy?: bool;
+ timeout?: number;
+ maximumAge?: number;
+}
+
+interface HTMLObjectElement extends HTMLElement, MSHTMLObjectElementExtensions, GetSVGDocument, DOML2DeprecatedMarginStyle_HTMLObjectElement, MSDataBindingExtensions, MSDataBindingRecordSetExtensions, DOML2DeprecatedAlignmentStyle_HTMLObjectElement, DOML2DeprecatedBorderStyle_HTMLObjectElement {
+ width: string;
+ codeType: string;
+ archive: string;
+ standby: string;
+ name: string;
+ useMap: string;
+ form: HTMLFormElement;
+ data: string;
+ height: string;
+ contentDocument: Document;
+ codeBase: string;
+ declare: bool;
+ type: string;
+ code: string;
+}
+declare var HTMLObjectElement: {
+ prototype: HTMLObjectElement;
+ new(): HTMLObjectElement;
+}
+
+interface MSHTMLMenuElementExtensions {
+}
+
+interface DocumentView {
+ defaultView: AbstractView;
+ elementFromPoint(x: number, y: number): Element;
+}
+
+interface StorageEvent extends Event {
+ oldValue: any;
+ newValue: any;
+ url: string;
+ storageArea: Storage;
+ key: string;
+ initStorageEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, keyArg: string, oldValueArg: any, newValueArg: any, urlArg: string, storageAreaArg: Storage): void;
+}
+declare var StorageEvent: {
+ prototype: StorageEvent;
+ new(): StorageEvent;
+}
+
+interface HTMLEmbedElement extends HTMLElement, GetSVGDocument, MSHTMLEmbedElementExtensions {
+ width: string;
+ src: string;
+ name: string;
+ height: string;
+}
+declare var HTMLEmbedElement: {
+ prototype: HTMLEmbedElement;
+ new(): HTMLEmbedElement;
+}
+
+interface CharacterData extends Node {
+ length: number;
+ data: string;
+ deleteData(offset: number, count: number): void;
+ replaceData(offset: number, count: number, arg: string): void;
+ appendData(arg: string): void;
+ insertData(offset: number, arg: string): void;
+ substringData(offset: number, count: number): string;
+}
+declare var CharacterData: {
+ prototype: CharacterData;
+ new(): CharacterData;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLTableSectionElement {
+ align: string;
+}
+
+interface HTMLOptGroupElement extends HTMLElement, MSDataBindingExtensions, MSHTMLOptGroupElementExtensions {
+ label: string;
+}
+declare var HTMLOptGroupElement: {
+ prototype: HTMLOptGroupElement;
+ new(): HTMLOptGroupElement;
+}
+
+interface HTMLIsIndexElement extends HTMLElement, MSHTMLIsIndexElementExtensions {
+ form: HTMLFormElement;
+ prompt: string;
+}
+declare var HTMLIsIndexElement: {
+ prototype: HTMLIsIndexElement;
+ new(): HTMLIsIndexElement;
+}
+
+interface SVGPathSegLinetoRel extends SVGPathSeg {
+ y: number;
+ x: number;
+}
+declare var SVGPathSegLinetoRel: {
+ prototype: SVGPathSegLinetoRel;
+ new(): SVGPathSegLinetoRel;
+}
+
+interface MSHTMLDocumentSelection {
+ selection: MSSelection;
+}
+
+interface DOMException {
+ code: number;
+ message: string;
+ toString(): string;
+ HIERARCHY_REQUEST_ERR: number;
+ NO_MODIFICATION_ALLOWED_ERR: number;
+ INVALID_MODIFICATION_ERR: number;
+ NAMESPACE_ERR: number;
+ INVALID_CHARACTER_ERR: number;
+ TYPE_MISMATCH_ERR: number;
+ ABORT_ERR: number;
+ INVALID_STATE_ERR: number;
+ SECURITY_ERR: number;
+ NETWORK_ERR: number;
+ WRONG_DOCUMENT_ERR: number;
+ QUOTA_EXCEEDED_ERR: number;
+ INDEX_SIZE_ERR: number;
+ DOMSTRING_SIZE_ERR: number;
+ SYNTAX_ERR: number;
+ SERIALIZE_ERR: number;
+ VALIDATION_ERR: number;
+ NOT_FOUND_ERR: number;
+ URL_MISMATCH_ERR: number;
+ PARSE_ERR: number;
+ NO_DATA_ALLOWED_ERR: number;
+ NOT_SUPPORTED_ERR: number;
+ INVALID_ACCESS_ERR: number;
+ INUSE_ATTRIBUTE_ERR: number;
+}
+declare var DOMException: {
+ prototype: DOMException;
+ new(): DOMException;
+ HIERARCHY_REQUEST_ERR: number;
+ NO_MODIFICATION_ALLOWED_ERR: number;
+ INVALID_MODIFICATION_ERR: number;
+ NAMESPACE_ERR: number;
+ INVALID_CHARACTER_ERR: number;
+ TYPE_MISMATCH_ERR: number;
+ ABORT_ERR: number;
+ INVALID_STATE_ERR: number;
+ SECURITY_ERR: number;
+ NETWORK_ERR: number;
+ WRONG_DOCUMENT_ERR: number;
+ QUOTA_EXCEEDED_ERR: number;
+ INDEX_SIZE_ERR: number;
+ DOMSTRING_SIZE_ERR: number;
+ SYNTAX_ERR: number;
+ SERIALIZE_ERR: number;
+ VALIDATION_ERR: number;
+ NOT_FOUND_ERR: number;
+ URL_MISMATCH_ERR: number;
+ PARSE_ERR: number;
+ NO_DATA_ALLOWED_ERR: number;
+ NOT_SUPPORTED_ERR: number;
+ INVALID_ACCESS_ERR: number;
+ INUSE_ATTRIBUTE_ERR: number;
+}
+
+interface MSCompatibleInfoCollection {
+ length: number;
+ item(index: number): MSCompatibleInfo;
+}
+declare var MSCompatibleInfoCollection: {
+ prototype: MSCompatibleInfoCollection;
+ new(): MSCompatibleInfoCollection;
+}
+
+interface MSHTMLIsIndexElementExtensions {
+ action: string;
+}
+
+interface SVGAnimatedBoolean {
+ animVal: bool;
+ baseVal: bool;
+}
+declare var SVGAnimatedBoolean: {
+ prototype: SVGAnimatedBoolean;
+ new(): SVGAnimatedBoolean;
+}
+
+interface SVGSwitchElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests {
+}
+declare var SVGSwitchElement: {
+ prototype: SVGSwitchElement;
+ new(): SVGSwitchElement;
+}
+
+interface MSHTMLIFrameElementExtensions extends DOML2DeprecatedMarginStyle_MSHTMLIFrameElementExtensions, DOML2DeprecatedBorderStyle_MSHTMLIFrameElementExtensions {
+ onload: (ev: Event) => any;
+ frameSpacing: any;
+ noResize: bool;
+}
+
+interface SVGPreserveAspectRatio {
+ align: number;
+ meetOrSlice: number;
+ SVG_PRESERVEASPECTRATIO_NONE: number;
+ SVG_PRESERVEASPECTRATIO_XMINYMID: number;
+ SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
+ SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
+ SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
+ SVG_MEETORSLICE_UNKNOWN: number;
+ SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
+ SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
+ SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
+ SVG_MEETORSLICE_MEET: number;
+ SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
+ SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
+ SVG_MEETORSLICE_SLICE: number;
+ SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
+}
+declare var SVGPreserveAspectRatio: {
+ prototype: SVGPreserveAspectRatio;
+ new(): SVGPreserveAspectRatio;
+ SVG_PRESERVEASPECTRATIO_NONE: number;
+ SVG_PRESERVEASPECTRATIO_XMINYMID: number;
+ SVG_PRESERVEASPECTRATIO_XMAXYMIN: number;
+ SVG_PRESERVEASPECTRATIO_XMINYMAX: number;
+ SVG_PRESERVEASPECTRATIO_XMAXYMAX: number;
+ SVG_MEETORSLICE_UNKNOWN: number;
+ SVG_PRESERVEASPECTRATIO_XMAXYMID: number;
+ SVG_PRESERVEASPECTRATIO_XMIDYMAX: number;
+ SVG_PRESERVEASPECTRATIO_XMINYMIN: number;
+ SVG_MEETORSLICE_MEET: number;
+ SVG_PRESERVEASPECTRATIO_XMIDYMID: number;
+ SVG_PRESERVEASPECTRATIO_XMIDYMIN: number;
+ SVG_MEETORSLICE_SLICE: number;
+ SVG_PRESERVEASPECTRATIO_UNKNOWN: number;
+}
+
+interface Attr extends Node, MSAttrExtensions {
+ specified: bool;
+ ownerElement: Element;
+ value: string;
+ name: string;
+}
+declare var Attr: {
+ prototype: Attr;
+ new(): Attr;
+}
+
+interface MSBorderColorStyle_HTMLTableRowElement {
+ borderColor: any;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLTableCaptionElement {
+ align: string;
+}
+
+interface PerformanceNavigation {
+ redirectCount: number;
+ type: number;
+ toJSON(): any;
+ TYPE_RELOAD: number;
+ TYPE_RESERVED: number;
+ TYPE_BACK_FORWARD: number;
+ TYPE_NAVIGATE: number;
+}
+declare var PerformanceNavigation: {
+ prototype: PerformanceNavigation;
+ new(): PerformanceNavigation;
+ TYPE_RELOAD: number;
+ TYPE_RESERVED: number;
+ TYPE_BACK_FORWARD: number;
+ TYPE_NAVIGATE: number;
+}
+
+interface HTMLBodyElementDOML2Deprecated {
+ link: any;
+ aLink: any;
+ text: any;
+ vLink: any;
+}
+
+interface SVGStopElement extends SVGElement, SVGStylable {
+ offset: SVGAnimatedNumber;
+}
+declare var SVGStopElement: {
+ prototype: SVGStopElement;
+ new(): SVGStopElement;
+}
+
+interface PositionCallback {
+ (position: Position): void;
+}
+
+interface SVGSymbolElement extends SVGElement, SVGStylable, SVGLangSpace, SVGFitToViewBox {
+}
+declare var SVGSymbolElement: {
+ prototype: SVGSymbolElement;
+ new(): SVGSymbolElement;
+}
+
+interface SVGElementInstanceList {
+ length: number;
+ item(index: number): SVGElementInstance;
+}
+declare var SVGElementInstanceList: {
+ prototype: SVGElementInstanceList;
+ new(): SVGElementInstanceList;
+}
+
+interface MSDataBindingRecordSetExtensions {
+ recordset: Object;
+ namedRecordset(dataMember: string, hierarchy?: any): Object;
+}
+
+interface CSSRuleList {
+ length: number;
+ item(index: number): CSSRule;
+ [index: number]: CSSRule;
+}
+declare var CSSRuleList: {
+ prototype: CSSRuleList;
+ new(): CSSRuleList;
+}
+
+interface MSHTMLTableColElementExtensions {
+}
+
+interface LinkStyle {
+ sheet: StyleSheet;
+}
+
+interface MSHTMLMarqueeElementExtensions {
+}
+
+interface HTMLVideoElement extends HTMLMediaElement {
+ width: number;
+ videoWidth: number;
+ videoHeight: number;
+ height: number;
+ poster: string;
+}
+declare var HTMLVideoElement: {
+ prototype: HTMLVideoElement;
+ new(): HTMLVideoElement;
+}
+
+interface MSXMLHttpRequestExtensions {
+ responseBody: any;
+ timeout: number;
+ ontimeout: (ev: Event) => any;
+}
+
+interface ClientRectList {
+ length: number;
+ item(index: number): ClientRect;
+ [index: number]: ClientRect;
+}
+declare var ClientRectList: {
+ prototype: ClientRectList;
+ new(): ClientRectList;
+}
+
+interface DOML2DeprecatedAlignmentStyle_HTMLTableCellElement {
+ align: string;
+}
+
+interface SVGMaskElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGLangSpace, SVGTests {
+ y: SVGAnimatedLength;
+ width: SVGAnimatedLength;
+ maskUnits: SVGAnimatedEnumeration;
+ maskContentUnits: SVGAnimatedEnumeration;
+ x: SVGAnimatedLength;
+ height: SVGAnimatedLength;
+}
+declare var SVGMaskElement: {
+ prototype: SVGMaskElement;
+ new(): SVGMaskElement;
+}
+
+declare var Audio: { new (src?: string): HTMLAudioElement; };
+declare var Option: { new (text?: string, value?: string, defaultSelected?: bool, selected?: bool): HTMLOptionElement; };
+declare var Image: { new (width?: number, height?: number): HTMLImageElement; };
+
+declare var ondragend: (ev: DragEvent) => any;
+declare var onkeydown: (ev: KeyboardEvent) => any;
+declare var ondragover: (ev: DragEvent) => any;
+declare var onkeyup: (ev: KeyboardEvent) => any;
+declare var onreset: (ev: Event) => any;
+declare var onmouseup: (ev: MouseEvent) => any;
+declare var ondragstart: (ev: DragEvent) => any;
+declare var ondrag: (ev: DragEvent) => any;
+declare var onmouseover: (ev: MouseEvent) => any;
+declare var ondragleave: (ev: DragEvent) => any;
+declare var history: History;
+declare var name: string;
+declare var onafterprint: (ev: Event) => any;
+declare var onpause: (ev: Event) => any;
+declare var onbeforeprint: (ev: Event) => any;
+declare var top: Window;
+declare var onmousedown: (ev: MouseEvent) => any;
+declare var onseeked: (ev: Event) => any;
+declare var opener: Window;
+declare var onclick: (ev: MouseEvent) => any;
+declare var onwaiting: (ev: Event) => any;
+declare var ononline: (ev: Event) => any;
+declare var ondurationchange: (ev: Event) => any;
+declare var frames: Window;
+declare var onblur: (ev: FocusEvent) => any;
+declare var onemptied: (ev: Event) => any;
+declare var onseeking: (ev: Event) => any;
+declare var oncanplay: (ev: Event) => any;
+declare var onstalled: (ev: Event) => any;
+declare var onmousemove: (ev: MouseEvent) => any;
+declare var onoffline: (ev: Event) => any;
+declare var length: number;
+declare var onbeforeunload: (ev: BeforeUnloadEvent) => any;
+declare var onratechange: (ev: Event) => any;
+declare var onstorage: (ev: StorageEvent) => any;
+declare var onloadstart: (ev: Event) => any;
+declare var ondragenter: (ev: DragEvent) => any;
+declare var onsubmit: (ev: Event) => any;
+declare var self: Window;
+declare var onprogress: (ev: any) => any;
+declare var ondblclick: (ev: MouseEvent) => any;
+declare var oncontextmenu: (ev: MouseEvent) => any;
+declare var onchange: (ev: Event) => any;
+declare var onloadedmetadata: (ev: Event) => any;
+declare var onplay: (ev: Event) => any;
+declare var onerror: ErrorFunction;
+declare var onplaying: (ev: Event) => any;
+declare var parent: Window;
+declare var location: Location;
+declare var oncanplaythrough: (ev: Event) => any;
+declare var onabort: (ev: UIEvent) => any;
+declare var onreadystatechange: (ev: Event) => any;
+declare var onkeypress: (ev: KeyboardEvent) => any;
+declare var frameElement: Element;
+declare var onloadeddata: (ev: Event) => any;
+declare var onsuspend: (ev: Event) => any;
+declare var window: Window;
+declare var onfocus: (ev: FocusEvent) => any;
+declare var onmessage: (ev: MessageEvent) => any;
+declare var ontimeupdate: (ev: Event) => any;
+declare var onresize: (ev: UIEvent) => any;
+declare var navigator: Navigator;
+declare var onselect: (ev: UIEvent) => any;
+declare var ondrop: (ev: DragEvent) => any;
+declare var onmouseout: (ev: MouseEvent) => any;
+declare var onended: (ev: Event) => any;
+declare var onhashchange: (ev: Event) => any;
+declare var onunload: (ev: Event) => any;
+declare var onscroll: (ev: UIEvent) => any;
+declare var onmousewheel: (ev: MouseWheelEvent) => any;
+declare var onload: (ev: Event) => any;
+declare var onvolumechange: (ev: Event) => any;
+declare var oninput: (ev: Event) => any;
+declare function alert(message?: string): void;
+declare function focus(): void;
+declare function print(): void;
+declare function prompt(message?: string, defaul?: string): string;
+declare function toString(): string;
+declare function open(url?: string, target?: string, features?: string, replace?: bool): Window;
+declare function close(): void;
+declare function confirm(message?: string): bool;
+declare function postMessage(message: any, targetOrigin: string, ports?: any): void;
+declare function showModalDialog(url?: string, argument?: any, options?: any): any;
+declare function blur(): void;
+declare function getSelection(): Selection;
+declare function getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration;
+declare function attachEvent(event: string, listener: EventListener): bool;
+declare function detachEvent(event: string, listener: EventListener): void;
+declare var status: string;
+declare var onmouseleave: (ev: MouseEvent) => any;
+declare var screenLeft: number;
+declare var offscreenBuffering: any;
+declare var maxConnectionsPerServer: number;
+declare var onmouseenter: (ev: MouseEvent) => any;
+declare var clipboardData: DataTransfer;
+declare var defaultStatus: string;
+declare var clientInformation: Navigator;
+declare var closed: bool;
+declare var onhelp: (ev: Event) => any;
+declare var external: BrowserPublic;
+declare var event: MSEventObj;
+declare var onfocusout: (ev: FocusEvent) => any;
+declare var screenTop: number;
+declare var onfocusin: (ev: FocusEvent) => any;
+declare function showModelessDialog(url?: string, argument?: any, options?: any): Window;
+declare function navigate(url: string): void;
+declare function resizeBy(x?: number, y?: number): void;
+declare function item(index: any): any;
+declare function resizeTo(x?: number, y?: number): void;
+declare function createPopup(arguments?: any): MSPopupWindow;
+declare function toStaticHTML(html: string): string;
+declare function execScript(code: string, language?: string): any;
+declare function msWriteProfilerMark(profilerMarkName: string): void;
+declare function moveTo(x?: number, y?: number): void;
+declare function moveBy(x?: number, y?: number): void;
+declare function showHelp(url: string, helpArg?: any, features?: string): void;
+declare var performance: any;
+declare var outerWidth: number;
+declare var pageXOffset: number;
+declare var innerWidth: number;
+declare var pageYOffset: number;
+declare var screenY: number;
+declare var outerHeight: number;
+declare var screen: Screen;
+declare var innerHeight: number;
+declare var screenX: number;
+declare function scroll(x?: number, y?: number): void;
+declare function scrollBy(x?: number, y?: number): void;
+declare function scrollTo(x?: number, y?: number): void;
+declare var styleMedia: StyleMedia;
+declare var document: Document;
+declare function removeEventListener(type: string, listener: EventListener, useCapture?: bool): void;
+declare function addEventListener(type: string, listener: EventListener, useCapture?: bool): void;
+declare function dispatchEvent(evt: Event): bool;
+declare var localStorage: Storage;
+declare var sessionStorage: Storage;
+declare function clearTimeout(handle: number): void;
+declare function setTimeout(expression: any, msec?: number, language?: any): number;
+declare function clearInterval(handle: number): void;
+declare function setInterval(expression: any, msec?: number, language?: any): number;
+
+
+/////////////////////////////
+/// IE10 DOM APIs
+/////////////////////////////
+
+interface HTMLBodyElement {
+ onpopstate: (ev: PopStateEvent) => any;
+}
+
+interface MSGestureEvent extends UIEvent {
+ offsetY: number;
+ translationY: number;
+ velocityExpansion: number;
+ velocityY: number;
+ velocityAngular: number;
+ translationX: number;
+ velocityX: number;
+ hwTimestamp: number;
+ offsetX: number;
+ screenX: number;
+ rotation: number;
+ expansion: number;
+ clientY: number;
+ screenY: number;
+ scale: number;
+ gestureObject: any;
+ clientX: number;
+ initGestureEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, offsetXArg: number, offsetYArg: number, translationXArg: number, translationYArg: number, scaleArg: number, expansionArg: number, rotationArg: number, velocityXArg: number, velocityYArg: number, velocityExpansionArg: number, velocityAngularArg: number, hwTimestampArg: number): void;
+ MSGESTURE_FLAG_BEGIN: number;
+ MSGESTURE_FLAG_END: number;
+ MSGESTURE_FLAG_CANCEL: number;
+ MSGESTURE_FLAG_INERTIA: number;
+ MSGESTURE_FLAG_NONE: number;
+}
+declare var MSGestureEvent: {
+ prototype: MSGestureEvent;
+ new(): MSGestureEvent;
+ MSGESTURE_FLAG_BEGIN: number;
+ MSGESTURE_FLAG_END: number;
+ MSGESTURE_FLAG_CANCEL: number;
+ MSGESTURE_FLAG_INERTIA: number;
+ MSGESTURE_FLAG_NONE: number;
+}
+
+interface HTMLAnchorElement {
+ text: string;
+}
+
+interface HTMLInputElement {
+ validationMessage: string;
+ files: FileList;
+ max: string;
+ formTarget: string;
+ willValidate: bool;
+ step: string;
+ autofocus: bool;
+ required: bool;
+ formEnctype: string;
+ valueAsNumber: number;
+ placeholder: string;
+ formMethod: string;
+ list: HTMLElement;
+ autocomplete: string;
+ min: string;
+ formAction: string;
+ pattern: string;
+ validity: ValidityState;
+ formNoValidate: string;
+ multiple: bool;
+ checkValidity(): bool;
+ stepDown(n?: number): void;
+ stepUp(n?: number): void;
+ setCustomValidity(error: string): void;
+}
+
+interface ErrorEvent extends Event {
+ colno: number;
+ filename: string;
+ lineno: number;
+ message: string;
+ initErrorEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, messageArg: string, filenameArg: string, linenoArg: number): void;
+}
+declare var ErrorEvent: {
+ prototype: ErrorEvent;
+ new(): ErrorEvent;
+}
+
+interface SVGFilterElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGLangSpace, SVGURIReference {
+ y: SVGAnimatedLength;
+ width: SVGAnimatedLength;
+ filterResX: SVGAnimatedInteger;
+ filterUnits: SVGAnimatedEnumeration;
+ primitiveUnits: SVGAnimatedEnumeration;
+ x: SVGAnimatedLength;
+ height: SVGAnimatedLength;
+ filterResY: SVGAnimatedInteger;
+ setFilterRes(filterResX: number, filterResY: number): void;
+}
+declare var SVGFilterElement: {
+ prototype: SVGFilterElement;
+ new(): SVGFilterElement;
+}
+
+interface TrackEvent extends Event {
+ track: any;
+}
+declare var TrackEvent: {
+ prototype: TrackEvent;
+ new(): TrackEvent;
+}
+
+interface SVGFEMergeNodeElement extends SVGElement {
+ in1: SVGAnimatedString;
+}
+declare var SVGFEMergeNodeElement: {
+ prototype: SVGFEMergeNodeElement;
+ new(): SVGFEMergeNodeElement;
+}
+
+interface SVGFEFloodElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+}
+declare var SVGFEFloodElement: {
+ prototype: SVGFEFloodElement;
+ new(): SVGFEFloodElement;
+}
+
+interface MSElementExtensions {
+ msRegionOverflow: string;
+ onmspointerdown: (ev: any) => any;
+ onmsgotpointercapture: (ev: any) => any;
+ onmsgesturedoubletap: (ev: any) => any;
+ onmspointerhover: (ev: any) => any;
+ onmsgesturehold: (ev: any) => any;
+ onmspointermove: (ev: any) => any;
+ onmsgesturechange: (ev: any) => any;
+ onmsgesturestart: (ev: any) => any;
+ onmspointercancel: (ev: any) => any;
+ onmsgestureend: (ev: any) => any;
+ onmsgesturetap: (ev: any) => any;
+ onmspointerout: (ev: any) => any;
+ onmsinertiastart: (ev: any) => any;
+ onmslostpointercapture: (ev: any) => any;
+ onmspointerover: (ev: any) => any;
+ msContentZoomFactor: number;
+ onmspointerup: (ev: any) => any;
+ msGetRegionContent(): MSRangeCollection;
+ msReleasePointerCapture(pointerId: number): void;
+ msSetPointerCapture(pointerId: number): void;
+}
+declare var MSElementExtensions: {
+ prototype: MSElementExtensions;
+ new(): MSElementExtensions;
+}
+
+interface MSCSSScrollTranslationProperties {
+ msScrollTranslation: string;
+}
+
+interface MSGesture {
+ target: Element;
+ addPointer(pointerId: number): void;
+ stop(): void;
+}
+declare var MSGesture: {
+ prototype: MSGesture;
+ new (): MSGesture;
+}
+
+interface TextTrackCue extends EventTarget {
+ onenter: (ev: Event) => any;
+ track: TextTrack;
+ endTime: number;
+ text: string;
+ pauseOnExit: bool;
+ id: string;
+ startTime: number;
+ onexit: (ev: Event) => any;
+ getCueAsHTML(): DocumentFragment;
+}
+declare var TextTrackCue: {
+ prototype: TextTrackCue;
+ new(): TextTrackCue;
+}
+
+interface MSHTMLDocumentViewExtensions {
+ msCSSOMElementFloatMetrics: bool;
+ msElementsFromPoint(x: number, y: number): NodeList;
+ msElementsFromRect(left: number, top: number, width: number, height: number): NodeList;
+}
+declare var MSHTMLDocumentViewExtensions: {
+ prototype: MSHTMLDocumentViewExtensions;
+ new(): MSHTMLDocumentViewExtensions;
+}
+
+interface MSStreamReader extends MSBaseReader {
+ error: DOMError;
+ readAsArrayBuffer(stream: MSStream, size?: number): void;
+ readAsBlob(stream: MSStream, size?: number): void;
+ readAsDataURL(stream: MSStream, size?: number): void;
+ readAsText(stream: MSStream, encoding?: string, size?: number): void;
+}
+declare var MSStreamReader: {
+ prototype: MSStreamReader;
+ new (): MSStreamReader;
+}
+
+interface CSSFlexibleBoxProperties {
+ msFlex: string;
+ msFlexDirection: string;
+ msFlexNegative: string;
+ msFlexPack: string;
+ msFlexWrap: string;
+ msFlexItemAlign: string;
+ msFlexOrder: string;
+ msFlexPositive: string;
+ msFlexAlign: string;
+ msFlexFlow: string;
+ msFlexPreferredSize: string;
+ msFlexLinePack: string;
+}
+
+interface DOMTokenList {
+ length: number;
+ contains(token: string): bool;
+ remove(token: string): void;
+ toggle(token: string): bool;
+ add(token: string): void;
+ item(index: number): string;
+ [index: number]: string;
+ toString(): string;
+}
+declare var DOMTokenList: {
+ prototype: DOMTokenList;
+ new(): DOMTokenList;
+}
+
+interface EventException {
+ name: string;
+}
+
+interface SVGFEFuncAElement extends SVGComponentTransferFunctionElement {
+}
+declare var SVGFEFuncAElement: {
+ prototype: SVGFEFuncAElement;
+ new(): SVGFEFuncAElement;
+}
+
+interface Performance {
+ now(): number;
+}
+
+interface SVGFETileElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ in1: SVGAnimatedString;
+}
+declare var SVGFETileElement: {
+ prototype: SVGFETileElement;
+ new(): SVGFETileElement;
+}
+
+interface SVGFEBlendElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ in2: SVGAnimatedString;
+ mode: SVGAnimatedEnumeration;
+ in1: SVGAnimatedString;
+ SVG_FEBLEND_MODE_DARKEN: number;
+ SVG_FEBLEND_MODE_UNKNOWN: number;
+ SVG_FEBLEND_MODE_MULTIPLY: number;
+ SVG_FEBLEND_MODE_NORMAL: number;
+ SVG_FEBLEND_MODE_SCREEN: number;
+ SVG_FEBLEND_MODE_LIGHTEN: number;
+}
+declare var SVGFEBlendElement: {
+ prototype: SVGFEBlendElement;
+ new(): SVGFEBlendElement;
+ SVG_FEBLEND_MODE_DARKEN: number;
+ SVG_FEBLEND_MODE_UNKNOWN: number;
+ SVG_FEBLEND_MODE_MULTIPLY: number;
+ SVG_FEBLEND_MODE_NORMAL: number;
+ SVG_FEBLEND_MODE_SCREEN: number;
+ SVG_FEBLEND_MODE_LIGHTEN: number;
+}
+
+interface WindowTimers extends WindowTimersExtension {
+}
+declare var WindowTimers: {
+ prototype: WindowTimers;
+ new(): WindowTimers;
+}
+
+interface CSSStyleDeclaration extends CSS2DTransformsProperties, CSSTransitionsProperties, CSSFontsProperties, MSCSSHighContrastProperties, CSSGridProperties, CSSAnimationsProperties, MSCSSContentZoomProperties, MSCSSScrollTranslationProperties, MSCSSTouchManipulationProperties, CSSFlexibleBoxProperties, MSCSSPositionedFloatsProperties, MSCSSRegionProperties, MSCSSSelectionBoundaryProperties, CSSMultiColumnProperties, CSSTextProperties, CSS3DTransformsProperties {
+}
+
+interface MessageChannel {
+ port2: MessagePort;
+ port1: MessagePort;
+}
+declare var MessageChannel: {
+ prototype: MessageChannel;
+ new (): MessageChannel;
+}
+
+interface SVGFEMergeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+}
+declare var SVGFEMergeElement: {
+ prototype: SVGFEMergeElement;
+ new(): SVGFEMergeElement;
+}
+
+interface Navigator extends MSFileSaver {
+}
+
+interface TransitionEvent extends Event {
+ propertyName: string;
+ elapsedTime: number;
+ initTransitionEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, propertyNameArg: string, elapsedTimeArg: number): void;
+}
+declare var TransitionEvent: {
+ prototype: TransitionEvent;
+ new(): TransitionEvent;
+}
+
+interface MediaQueryList {
+ matches: bool;
+ media: string;
+ addListener(listener: MediaQueryListListener): void;
+ removeListener(listener: MediaQueryListListener): void;
+}
+declare var MediaQueryList: {
+ prototype: MediaQueryList;
+ new(): MediaQueryList;
+}
+
+interface DOMError {
+ name: string;
+ toString(): string;
+}
+declare var DOMError: {
+ prototype: DOMError;
+ new(): DOMError;
+}
+
+interface SVGFEPointLightElement extends SVGElement {
+ y: SVGAnimatedNumber;
+ x: SVGAnimatedNumber;
+ z: SVGAnimatedNumber;
+}
+declare var SVGFEPointLightElement: {
+ prototype: SVGFEPointLightElement;
+ new(): SVGFEPointLightElement;
+}
+
+interface CSSFontsProperties {
+ msFontFeatureSettings: string;
+ fontFeatureSettings: string;
+}
+
+interface CloseEvent extends Event {
+ wasClean: bool;
+ reason: string;
+ code: number;
+ initCloseEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, wasCleanArg: bool, codeArg: number, reasonArg: string): void;
+}
+declare var CloseEvent: {
+ prototype: CloseEvent;
+ new(): CloseEvent;
+}
+
+interface WebSocket extends EventTarget {
+ protocol: string;
+ readyState: number;
+ bufferedAmount: number;
+ onopen: (ev: Event) => any;
+ extensions: string;
+ onmessage: (ev: any) => any;
+ onclose: (ev: CloseEvent) => any;
+ onerror: (ev: ErrorEvent) => any;
+ binaryType: string;
+ url: string;
+ close(code?: number, reason?: string): void;
+ send(data: any): void;
+ OPEN: number;
+ CLOSING: number;
+ CONNECTING: number;
+ CLOSED: number;
+}
+declare var WebSocket: {
+ prototype: WebSocket;
+ new (url: string): WebSocket;
+ new (url: string, prototcol: string): WebSocket;
+ new (url: string, prototcol: string[]): WebSocket;
+ OPEN: number;
+ CLOSING: number;
+ CONNECTING: number;
+ CLOSED: number;
+}
+
+interface ProgressEvent extends Event {
+ loaded: number;
+ lengthComputable: bool;
+ total: number;
+ initProgressEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, lengthComputableArg: bool, loadedArg: number, totalArg: number): void;
+}
+declare var ProgressEvent: {
+ prototype: ProgressEvent;
+ new(): ProgressEvent;
+}
+
+interface HTMLCanvasElement {
+ msToBlob(): Blob;
+}
+
+interface IDBObjectStore {
+ indexNames: DOMStringList;
+ name: string;
+ transaction: IDBTransaction;
+ keyPath: string;
+ count(key?: any): IDBRequest;
+ add(value: any, key?: any): IDBRequest;
+ clear(): IDBRequest;
+ createIndex(name: string, keyPath: string, optionalParameters?: any): IDBIndex;
+ put(value: any, key?: any): IDBRequest;
+ openCursor(range?: any, direction?: string): IDBRequest;
+ deleteIndex(indexName: string): void;
+ index(name: string): IDBIndex;
+ get(key: any): IDBRequest;
+ delet(key: any): IDBRequest;
+}
+declare var IDBObjectStore: {
+ prototype: IDBObjectStore;
+ new(): IDBObjectStore;
+}
+
+interface ObjectURLOptions {
+ oneTimeOnly?: bool;
+}
+
+interface SVGFEGaussianBlurElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ stdDeviationX: SVGAnimatedNumber;
+ in1: SVGAnimatedString;
+ stdDeviationY: SVGAnimatedNumber;
+ setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
+}
+declare var SVGFEGaussianBlurElement: {
+ prototype: SVGFEGaussianBlurElement;
+ new(): SVGFEGaussianBlurElement;
+}
+
+interface MSHTMLDocumentExtensions {
+ onmspointerdown: (ev: any) => any;
+ onmspointercancel: (ev: any) => any;
+ onmsgesturedoubletap: (ev: any) => any;
+ onmsgesturetap: (ev: any) => any;
+ onmsgestureend: (ev: any) => any;
+ onmspointerout: (ev: any) => any;
+ onmsmanipulationstatechanged: (ev: any) => any;
+ onmsinertiastart: (ev: any) => any;
+ onmspointerhover: (ev: any) => any;
+ onmscontentzoom: (ev: any) => any;
+ onmsgesturehold: (ev: any) => any;
+ onmspointermove: (ev: any) => any;
+ onmspointerover: (ev: any) => any;
+ onmsgesturechange: (ev: any) => any;
+ onmsgesturestart: (ev: any) => any;
+ onmspointerup: (ev: any) => any;
+}
+declare var MSHTMLDocumentExtensions: {
+ prototype: MSHTMLDocumentExtensions;
+ new(): MSHTMLDocumentExtensions;
+}
+
+interface MSCSSSelectionBoundaryProperties {
+ msUserSelect: string;
+}
+
+interface SVGFilterPrimitiveStandardAttributes extends SVGStylable {
+ y: SVGAnimatedLength;
+ width: SVGAnimatedLength;
+ x: SVGAnimatedLength;
+ height: SVGAnimatedLength;
+ result: SVGAnimatedString;
+}
+
+interface IDBVersionChangeEvent extends Event {
+ newVersion: number;
+ oldVersion: number;
+}
+declare var IDBVersionChangeEvent: {
+ prototype: IDBVersionChangeEvent;
+ new(): IDBVersionChangeEvent;
+}
+
+interface IDBIndex {
+ unique: bool;
+ name: string;
+ keyPath: string;
+ objectStore: IDBObjectStore;
+ count(key?: any): IDBRequest;
+ getKey(key: any): IDBRequest;
+ openKeyCursor(range?: IDBKeyRange, direction?: string): IDBRequest;
+ get(key: any): IDBRequest;
+ openCursor(range?: IDBKeyRange, direction?: string): IDBRequest;
+}
+declare var IDBIndex: {
+ prototype: IDBIndex;
+ new(): IDBIndex;
+}
+
+interface FileList {
+ length: number;
+ item(index: number): File;
+ [index: number]: File;
+}
+declare var FileList: {
+ prototype: FileList;
+ new(): FileList;
+}
+
+interface IDBCursor {
+ source: any;
+ direction: string;
+ key: any;
+ primaryKey: any;
+ advance(count: number): void;
+ delet(): IDBRequest;
+ continu(key?: any): void;
+ update(value: any): IDBRequest;
+}
+declare var IDBCursor: {
+ prototype: IDBCursor;
+ new(): IDBCursor;
+}
+
+interface CSSAnimationsProperties {
+ animationFillMode: string;
+ msAnimationDirection: string;
+ msAnimationDelay: string;
+ msAnimationFillMode: string;
+ animationIterationCount: string;
+ msAnimationPlayState: string;
+ msAnimationIterationCount: string;
+ animationDelay: string;
+ animationTimingFunction: string;
+ msAnimation: string;
+ animation: string;
+ animationDirection: string;
+ animationDuration: string;
+ animationName: string;
+ animationPlayState: string;
+ msAnimationTimingFunction: string;
+ msAnimationName: string;
+ msAnimationDuration: string;
+}
+
+interface SVGFESpecularLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ kernelUnitLengthY: SVGAnimatedNumber;
+ surfaceScale: SVGAnimatedNumber;
+ specularExponent: SVGAnimatedNumber;
+ in1: SVGAnimatedString;
+ kernelUnitLengthX: SVGAnimatedNumber;
+ specularConstant: SVGAnimatedNumber;
+}
+declare var SVGFESpecularLightingElement: {
+ prototype: SVGFESpecularLightingElement;
+ new(): SVGFESpecularLightingElement;
+}
+
+interface File extends Blob {
+ lastModifiedDate: any;
+ name: string;
+}
+declare var File: {
+ prototype: File;
+ new(): File;
+}
+
+interface URL {
+ revokeObjectURL(url: string): void;
+ createObjectURL(object: any, options?: ObjectURLOptions): string;
+}
+declare var URL: URL;
+
+interface RangeException {
+ name: string;
+}
+
+interface IDBCursorWithValue extends IDBCursor {
+ value: any;
+}
+declare var IDBCursorWithValue: {
+ prototype: IDBCursorWithValue;
+ new(): IDBCursorWithValue;
+}
+
+interface HTMLTextAreaElement {
+ validationMessage: string;
+ autofocus: bool;
+ validity: ValidityState;
+ required: bool;
+ maxLength: number;
+ willValidate: bool;
+ placeholder: string;
+ checkValidity(): bool;
+ setCustomValidity(error: string): void;
+}
+
+interface XMLHttpRequestEventTarget extends EventTarget {
+ onprogress: (ev: ProgressEvent) => any;
+ onerror: (ev: ErrorEvent) => any;
+ onload: (ev: any) => any;
+ ontimeout: (ev: any) => any;
+ onabort: (ev: any) => any;
+ onloadstart: (ev: any) => any;
+ onloadend: (ev: ProgressEvent) => any;
+}
+declare var XMLHttpRequestEventTarget: {
+ prototype: XMLHttpRequestEventTarget;
+ new(): XMLHttpRequestEventTarget;
+}
+
+interface IDBEnvironment {
+ msIndexedDB: IDBFactory;
+ indexedDB: IDBFactory;
+}
+
+interface AudioTrackList extends EventTarget {
+ length: number;
+ onchange: (ev: any) => any;
+ onaddtrack: (ev: TrackEvent) => any;
+ getTrackById(id: string): AudioTrack;
+ item(index: number): AudioTrack;
+ [index: number]: AudioTrack;
+}
+declare var AudioTrackList: {
+ prototype: AudioTrackList;
+ new(): AudioTrackList;
+}
+
+interface MSBaseReader extends EventTarget {
+ onprogress: (ev: ProgressEvent) => any;
+ readyState: number;
+ onabort: (ev: any) => any;
+ onloadend: (ev: ProgressEvent) => any;
+ onerror: (ev: ErrorEvent) => any;
+ onload: (ev: any) => any;
+ onloadstart: (ev: any) => any;
+ result: any;
+ abort(): void;
+ LOADING: number;
+ EMPTY: number;
+ DONE: number;
+}
+
+interface History {
+ state: any;
+ replaceState(statedata: any, title: string, url?: string): void;
+ pushState(statedata: any, title: string, url?: string): void;
+}
+
+interface MSProtocol {
+ protocol: string;
+}
+declare var MSProtocol: {
+ prototype: MSProtocol;
+ new(): MSProtocol;
+}
+
+interface SVGFEMorphologyElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ operator: SVGAnimatedEnumeration;
+ radiusX: SVGAnimatedNumber;
+ radiusY: SVGAnimatedNumber;
+ in1: SVGAnimatedString;
+ SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
+ SVG_MORPHOLOGY_OPERATOR_ERODE: number;
+ SVG_MORPHOLOGY_OPERATOR_DILATE: number;
+}
+declare var SVGFEMorphologyElement: {
+ prototype: SVGFEMorphologyElement;
+ new(): SVGFEMorphologyElement;
+ SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number;
+ SVG_MORPHOLOGY_OPERATOR_ERODE: number;
+ SVG_MORPHOLOGY_OPERATOR_DILATE: number;
+}
+
+interface HTMLSelectElement {
+ validationMessage: string;
+ autofocus: bool;
+ validity: ValidityState;
+ required: bool;
+ willValidate: bool;
+ checkValidity(): bool;
+ setCustomValidity(error: string): void;
+}
+
+interface CSSTransitionsProperties {
+ transition: string;
+ transitionDelay: string;
+ transitionDuration: string;
+ msTransitionTimingFunction: string;
+ msTransition: string;
+ msTransitionDuration: string;
+ transitionTimingFunction: string;
+ msTransitionDelay: string;
+ transitionProperty: string;
+ msTransitionProperty: string;
+}
+
+interface SVGFEFuncRElement extends SVGComponentTransferFunctionElement {
+}
+declare var SVGFEFuncRElement: {
+ prototype: SVGFEFuncRElement;
+ new(): SVGFEFuncRElement;
+}
+
+interface CSSRule {
+ KEYFRAMES_RULE: number;
+ KEYFRAME_RULE: number;
+ VIEWPORT_RULE: number;
+}
+//declare var CSSRule: {
+// KEYFRAMES_RULE: number;
+// KEYFRAME_RULE: number;
+// VIEWPORT_RULE: number;
+//}
+
+interface WindowTimersExtension {
+ msSetImmediate(expression: any, ...args: any[]): number;
+ clearImmediate(handle: number): void;
+ msClearImmediate(handle: number): void;
+ setImmediate(expression: any, ...args: any[]): number;
+}
+
+interface SVGFEDisplacementMapElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ in2: SVGAnimatedString;
+ xChannelSelector: SVGAnimatedEnumeration;
+ yChannelSelector: SVGAnimatedEnumeration;
+ scale: SVGAnimatedNumber;
+ in1: SVGAnimatedString;
+ SVG_CHANNEL_B: number;
+ SVG_CHANNEL_R: number;
+ SVG_CHANNEL_G: number;
+ SVG_CHANNEL_UNKNOWN: number;
+ SVG_CHANNEL_A: number;
+}
+declare var SVGFEDisplacementMapElement: {
+ prototype: SVGFEDisplacementMapElement;
+ new(): SVGFEDisplacementMapElement;
+ SVG_CHANNEL_B: number;
+ SVG_CHANNEL_R: number;
+ SVG_CHANNEL_G: number;
+ SVG_CHANNEL_UNKNOWN: number;
+ SVG_CHANNEL_A: number;
+}
+
+interface MSCSSContentZoomProperties {
+ msContentZoomLimit: string;
+ msContentZooming: string;
+ msContentZoomSnapType: string;
+ msContentZoomLimitMax: any;
+ msContentZoomSnapPoints: string;
+ msContentZoomSnap: string;
+ msContentZoomLimitMin: any;
+ msContentZoomChaining: string;
+}
+
+interface AnimationEvent extends Event {
+ animationName: string;
+ elapsedTime: number;
+ initAnimationEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, animationNameArg: string, elapsedTimeArg: number): void;
+}
+declare var AnimationEvent: {
+ prototype: AnimationEvent;
+ new(): AnimationEvent;
+}
+
+interface SVGComponentTransferFunctionElement extends SVGElement {
+ tableValues: SVGAnimatedNumberList;
+ slope: SVGAnimatedNumber;
+ type: SVGAnimatedEnumeration;
+ exponent: SVGAnimatedNumber;
+ amplitude: SVGAnimatedNumber;
+ intercept: SVGAnimatedNumber;
+ offset: SVGAnimatedNumber;
+ SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
+ SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
+ SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
+ SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
+ SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
+ SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
+}
+declare var SVGComponentTransferFunctionElement: {
+ prototype: SVGComponentTransferFunctionElement;
+ new(): SVGComponentTransferFunctionElement;
+ SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number;
+ SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number;
+ SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number;
+ SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number;
+ SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number;
+ SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number;
+}
+
+interface MSRangeCollection {
+ length: number;
+ item(index: number): Range;
+ [index: number]: Range;
+}
+declare var MSRangeCollection: {
+ prototype: MSRangeCollection;
+ new(): MSRangeCollection;
+}
+
+interface MSHTMLElementExtensions {
+ onmscontentzoom: (ev: any) => any;
+ onmsmanipulationstatechanged: (ev: any) => any;
+}
+declare var MSHTMLElementExtensions: {
+ prototype: MSHTMLElementExtensions;
+ new(): MSHTMLElementExtensions;
+}
+
+interface MSCSSPositionedFloatsProperties {
+ msWrapMargin: any;
+ msWrapFlow: string;
+}
+
+interface SVGException {
+ name: string;
+}
+
+interface SVGFEDistantLightElement extends SVGElement {
+ azimuth: SVGAnimatedNumber;
+ elevation: SVGAnimatedNumber;
+}
+declare var SVGFEDistantLightElement: {
+ prototype: SVGFEDistantLightElement;
+ new(): SVGFEDistantLightElement;
+}
+
+interface MSCSSRegionProperties {
+ msFlowFrom: string;
+ msFlowInto: string;
+ msWrapThrough: string;
+}
+
+interface SVGFEFuncBElement extends SVGComponentTransferFunctionElement {
+}
+declare var SVGFEFuncBElement: {
+ prototype: SVGFEFuncBElement;
+ new(): SVGFEFuncBElement;
+}
+
+interface IDBKeyRange {
+ upper: any;
+ upperOpen: bool;
+ lower: any;
+ lowerOpen: bool;
+ bound(lower: any, upper: any, lowerOpen?: bool, upperOpen?: bool): IDBKeyRange;
+ only(value: any): IDBKeyRange;
+ lowerBound(bound: any, open?: bool): IDBKeyRange;
+ upperBound(bound: any, open?: bool): IDBKeyRange;
+}
+declare var IDBKeyRange: {
+ prototype: IDBKeyRange;
+ new(): IDBKeyRange;
+}
+
+interface WindowConsole {
+ console: Console;
+}
+
+interface SVG1_1Properties {
+ floodOpacity: string;
+ floodColor: string;
+ filter: string;
+ lightingColor: string;
+ enableBackground: string;
+ colorInterpolationFilters: string;
+}
+declare var SVG1_1Properties: {
+ prototype: SVG1_1Properties;
+ new(): SVG1_1Properties;
+}
+
+interface IDBTransaction extends EventTarget {
+ oncomplete: (ev: Event) => any;
+ db: IDBDatabase;
+ mode: string;
+ error: DOMError;
+ onerror: (ev: ErrorEvent) => any;
+ onabort: (ev: any) => any;
+ abort(): void;
+ objectStore(name: string): IDBObjectStore;
+}
+declare var IDBTransaction: {
+ prototype: IDBTransaction;
+ new(): IDBTransaction;
+}
+
+interface MSWindowExtensions {
+ onmspointerdown: (ev: any) => any;
+ onmspointercancel: (ev: any) => any;
+ onmsgesturedoubletap: (ev: any) => any;
+ onmsgestureend: (ev: any) => any;
+ onmsgesturetap: (ev: any) => any;
+ onmspointerout: (ev: any) => any;
+ onmspointerhover: (ev: any) => any;
+ onmsinertiastart: (ev: any) => any;
+ onmspointermove: (ev: any) => any;
+ onmsgesturehold: (ev: any) => any;
+ onmspointerover: (ev: any) => any;
+ onmsgesturechange: (ev: any) => any;
+ onmsgesturestart: (ev: any) => any;
+ onmspointerup: (ev: any) => any;
+ msIsStaticHTML(html: string): bool;
+}
+declare var MSWindowExtensions: {
+ prototype: MSWindowExtensions;
+ new(): MSWindowExtensions;
+}
+
+interface AudioTrack {
+ kind: string;
+ language: string;
+ id: string;
+ label: string;
+ enabled: bool;
+}
+declare var AudioTrack: {
+ prototype: AudioTrack;
+ new(): AudioTrack;
+}
+
+interface SVGFEConvolveMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ orderY: SVGAnimatedInteger;
+ kernelUnitLengthY: SVGAnimatedNumber;
+ orderX: SVGAnimatedInteger;
+ preserveAlpha: SVGAnimatedBoolean;
+ kernelMatrix: SVGAnimatedNumberList;
+ edgeMode: SVGAnimatedEnumeration;
+ kernelUnitLengthX: SVGAnimatedNumber;
+ bias: SVGAnimatedNumber;
+ targetX: SVGAnimatedInteger;
+ targetY: SVGAnimatedInteger;
+ divisor: SVGAnimatedNumber;
+ in1: SVGAnimatedString;
+ SVG_EDGEMODE_WRAP: number;
+ SVG_EDGEMODE_DUPLICATE: number;
+ SVG_EDGEMODE_UNKNOWN: number;
+ SVG_EDGEMODE_NONE: number;
+}
+declare var SVGFEConvolveMatrixElement: {
+ prototype: SVGFEConvolveMatrixElement;
+ new(): SVGFEConvolveMatrixElement;
+ SVG_EDGEMODE_WRAP: number;
+ SVG_EDGEMODE_DUPLICATE: number;
+ SVG_EDGEMODE_UNKNOWN: number;
+ SVG_EDGEMODE_NONE: number;
+}
+
+interface TextTrackCueList {
+ length: number;
+ item(index: number): TextTrackCue;
+ [index: number]: TextTrackCue;
+ getCueById(id: string): TextTrackCue;
+}
+declare var TextTrackCueList: {
+ prototype: TextTrackCueList;
+ new(): TextTrackCueList;
+}
+
+interface CSSKeyframesRule extends CSSRule {
+ name: string;
+ cssRules: CSSRuleList;
+ findRule(rule: string): CSSKeyframeRule;
+ deleteRule(rule: string): void;
+ appendRule(rule: string): void;
+}
+declare var CSSKeyframesRule: {
+ prototype: CSSKeyframesRule;
+ new(): CSSKeyframesRule;
+}
+
+interface MSCSSTouchManipulationProperties {
+ msScrollSnapPointsY: string;
+ msOverflowStyle: string;
+ msScrollLimitXMax: any;
+ msScrollSnapType: string;
+ msScrollSnapPointsX: string;
+ msScrollLimitYMax: any;
+ msScrollSnapY: string;
+ msScrollLimitXMin: any;
+ msScrollLimitYMin: any;
+ msScrollChaining: string;
+ msTouchAction: string;
+ msScrollSnapX: string;
+ msScrollLimit: string;
+ msScrollRails: string;
+ msTouchSelect: string;
+}
+
+interface Window extends WindowAnimationTiming, WindowBase64, IDBEnvironment, WindowConsole {
+ onpopstate: (ev: PopStateEvent) => any;
+ applicationCache: ApplicationCache;
+ matchMedia(mediaQuery: string): MediaQueryList;
+ msMatchMedia(mediaQuery: string): MediaQueryList;
+}
+
+interface SVGFETurbulenceElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ baseFrequencyX: SVGAnimatedNumber;
+ numOctaves: SVGAnimatedInteger;
+ type: SVGAnimatedEnumeration;
+ baseFrequencyY: SVGAnimatedNumber;
+ stitchTiles: SVGAnimatedEnumeration;
+ seed: SVGAnimatedNumber;
+ SVG_STITCHTYPE_UNKNOWN: number;
+ SVG_STITCHTYPE_NOSTITCH: number;
+ SVG_TURBULENCE_TYPE_UNKNOWN: number;
+ SVG_TURBULENCE_TYPE_TURBULENCE: number;
+ SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
+ SVG_STITCHTYPE_STITCH: number;
+}
+declare var SVGFETurbulenceElement: {
+ prototype: SVGFETurbulenceElement;
+ new(): SVGFETurbulenceElement;
+ SVG_STITCHTYPE_UNKNOWN: number;
+ SVG_STITCHTYPE_NOSTITCH: number;
+ SVG_TURBULENCE_TYPE_UNKNOWN: number;
+ SVG_TURBULENCE_TYPE_TURBULENCE: number;
+ SVG_TURBULENCE_TYPE_FRACTALNOISE: number;
+ SVG_STITCHTYPE_STITCH: number;
+}
+
+interface TextTrackList {
+ length: number;
+ item(index: number): TextTrack;
+ [index: number]: TextTrack;
+}
+declare var TextTrackList: {
+ prototype: TextTrackList;
+ new(): TextTrackList;
+}
+
+interface WindowAnimationTiming {
+ animationStartTime: number;
+ msAnimationStartTime: number;
+ msCancelRequestAnimationFrame(handle: number): void;
+ cancelAnimationFrame(handle: number): void;
+ requestAnimationFrame(callback: FrameRequestCallback): number;
+ msRequestAnimationFrame(callback: FrameRequestCallback): number;
+}
+
+interface SVGFEFuncGElement extends SVGComponentTransferFunctionElement {
+}
+declare var SVGFEFuncGElement: {
+ prototype: SVGFEFuncGElement;
+ new(): SVGFEFuncGElement;
+}
+
+interface SVGFEColorMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ in1: SVGAnimatedString;
+ type: SVGAnimatedEnumeration;
+ values: SVGAnimatedNumberList;
+ SVG_FECOLORMATRIX_TYPE_SATURATE: number;
+ SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
+ SVG_FECOLORMATRIX_TYPE_MATRIX: number;
+ SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
+ SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
+}
+declare var SVGFEColorMatrixElement: {
+ prototype: SVGFEColorMatrixElement;
+ new(): SVGFEColorMatrixElement;
+ SVG_FECOLORMATRIX_TYPE_SATURATE: number;
+ SVG_FECOLORMATRIX_TYPE_UNKNOWN: number;
+ SVG_FECOLORMATRIX_TYPE_MATRIX: number;
+ SVG_FECOLORMATRIX_TYPE_HUEROTATE: number;
+ SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number;
+}
+
+interface Console {
+ info(): void;
+ info(message: any, ...optionalParams: any[]): void;
+ profile(reportName?: string): bool;
+ assert(): void;
+ assert(test: bool): void;
+ assert(test: bool, message: any, ...optionalParams: any[]): void;
+ msIsIndependentlyComposed(element: Element): bool;
+ clear(): bool;
+ dir(): bool;
+ dir(value: any, ...optionalParams: any[]): bool;
+ warn(): void;
+ warn(message: any, ...optionalParams: any[]): void;
+ error(): void;
+ error(message: any, ...optionalParams: any[]): void;
+ log(): void;
+ log(message: any, ...optionalParams: any[]): void;
+ profileEnd(): bool;
+}
+declare var Console: {
+ prototype: Console;
+ new(): Console;
+}
+
+interface SVGFESpotLightElement extends SVGElement {
+ pointsAtY: SVGAnimatedNumber;
+ y: SVGAnimatedNumber;
+ limitingConeAngle: SVGAnimatedNumber;
+ specularExponent: SVGAnimatedNumber;
+ x: SVGAnimatedNumber;
+ pointsAtZ: SVGAnimatedNumber;
+ z: SVGAnimatedNumber;
+ pointsAtX: SVGAnimatedNumber;
+}
+declare var SVGFESpotLightElement: {
+ prototype: SVGFESpotLightElement;
+ new(): SVGFESpotLightElement;
+}
+
+interface DocumentVisibility {
+ msHidden: bool;
+ msVisibilityState: string;
+ visibilityState: string;
+ hidden: bool;
+}
+
+interface WindowBase64 {
+ btoa(rawString: string): string;
+ atob(encodedString: string): string;
+}
+
+interface IDBDatabase extends EventTarget {
+ version: string;
+ name: string;
+ objectStoreNames: DOMStringList;
+ onerror: (ev: ErrorEvent) => any;
+ onabort: (ev: any) => any;
+ createObjectStore(name: string, optionalParameters?: any): IDBObjectStore;
+ close(): void;
+ transaction(storeNames: any, mode?: string): IDBTransaction;
+ deleteObjectStore(name: string): void;
+}
+declare var IDBDatabase: {
+ prototype: IDBDatabase;
+ new(): IDBDatabase;
+}
+
+interface MSProtocolsCollection {
+}
+declare var MSProtocolsCollection: {
+ prototype: MSProtocolsCollection;
+ new(): MSProtocolsCollection;
+}
+
+interface DOMStringList {
+ length: number;
+ contains(str: string): bool;
+ item(index: number): string;
+ [index: number]: string;
+}
+declare var DOMStringList: {
+ prototype: DOMStringList;
+ new(): DOMStringList;
+}
+
+interface CSSMultiColumnProperties {
+ breakAfter: string;
+ columnSpan: string;
+ columnRule: string;
+ columnFill: string;
+ columnRuleStyle: string;
+ breakBefore: string;
+ columnCount: any;
+ breakInside: string;
+ columnWidth: any;
+ columns: string;
+ columnRuleColor: any;
+ columnGap: any;
+ columnRuleWidth: any;
+}
+
+interface IDBOpenDBRequest extends IDBRequest {
+ onupgradeneeded: (ev: IDBVersionChangeEvent) => any;
+ onblocked: (ev: Event) => any;
+}
+declare var IDBOpenDBRequest: {
+ prototype: IDBOpenDBRequest;
+ new(): IDBOpenDBRequest;
+}
+
+interface HTMLButtonElement {
+ validationMessage: string;
+ formTarget: string;
+ willValidate: bool;
+ formAction: string;
+ autofocus: bool;
+ validity: ValidityState;
+ formNoValidate: string;
+ formEnctype: string;
+ formMethod: string;
+ checkValidity(): bool;
+ setCustomValidity(error: string): void;
+}
+
+interface HTMLProgressElement extends HTMLElement {
+ value: number;
+ max: number;
+ position: number;
+ form: HTMLFormElement;
+}
+declare var HTMLProgressElement: {
+ prototype: HTMLProgressElement;
+ new(): HTMLProgressElement;
+}
+
+interface SVGFEOffsetElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ dy: SVGAnimatedNumber;
+ in1: SVGAnimatedString;
+ dx: SVGAnimatedNumber;
+}
+declare var SVGFEOffsetElement: {
+ prototype: SVGFEOffsetElement;
+ new(): SVGFEOffsetElement;
+}
+
+interface HTMLFormElement {
+ autocomplete: string;
+ noValidate: bool;
+ checkValidity(): bool;
+}
+
+interface MSUnsafeFunctionCallback {
+ (): any;
+}
+
+interface Document extends DocumentVisibility {
+}
+
+interface MessageEvent extends Event {
+ ports: any;
+}
+
+interface HTMLScriptElement {
+ async: bool;
+}
+
+interface HTMLMediaElement extends MSHTMLMediaElementExtensions {
+ textTracks: TextTrackList;
+ audioTracks: AudioTrackList;
+}
+
+interface TextTrack extends EventTarget {
+ language: string;
+ mode: number;
+ readyState: string;
+ activeCues: TextTrackCueList;
+ cues: TextTrackCueList;
+ oncuechange: (ev: Event) => any;
+ kind: string;
+ onload: (ev: any) => any;
+ onerror: (ev: ErrorEvent) => any;
+ label: string;
+ ERROR: number;
+ SHOWING: number;
+ LOADING: number;
+ LOADED: number;
+ NONE: number;
+ HIDDEN: number;
+ DISABLED: number;
+}
+declare var TextTrack: {
+ prototype: TextTrack;
+ new(): TextTrack;
+ ERROR: number;
+ SHOWING: number;
+ LOADING: number;
+ LOADED: number;
+ NONE: number;
+ HIDDEN: number;
+ DISABLED: number;
+}
+
+interface MediaQueryListListener {
+ (mql: MediaQueryList): void;
+}
+
+interface IDBRequest extends EventTarget {
+ source: any;
+ onsuccess: (ev: Event) => any;
+ error: DOMError;
+ transaction: IDBTransaction;
+ onerror: (ev: ErrorEvent) => any;
+ readyState: string;
+ result: any;
+}
+declare var IDBRequest: {
+ prototype: IDBRequest;
+ new(): IDBRequest;
+}
+
+interface MessagePort extends EventTarget {
+ onmessage: (ev: any) => any;
+ close(): void;
+ postMessage(message: any, ports?: any): void;
+ start(): void;
+}
+declare var MessagePort: {
+ prototype: MessagePort;
+ new(): MessagePort;
+}
+
+interface FileReader extends MSBaseReader {
+ error: DOMError;
+ readAsArrayBuffer(blob: Blob): void;
+ readAsDataURL(blob: Blob): void;
+ readAsText(blob: Blob, encoding?: string): void;
+}
+declare var FileReader: {
+ prototype: FileReader;
+ new (): FileReader;
+}
+
+interface Blob {
+ type: string;
+ size: number;
+ msDetachStream(): any;
+ slice(start?: number, end?: number, contentType?: string): Blob;
+ close(): void;
+ msClose(): void;
+}
+interface BlobPropertyBag {
+ /** Corresponds to the 'type' property of the Blob object */
+ type?: string;
+ /** Either 'transparent' or 'native' */
+ endings?: string;
+}
+declare var Blob: {
+ prototype: Blob;
+ new (blobParts?: any[], options?: BlobPropertyBag): Blob;
+}
+
+interface ApplicationCache extends EventTarget {
+ status: number;
+ ondownloading: (ev: Event) => any;
+ onprogress: (ev: ProgressEvent) => any;
+ onupdateready: (ev: Event) => any;
+ oncached: (ev: Event) => any;
+ onobsolete: (ev: Event) => any;
+ onerror: (ev: ErrorEvent) => any;
+ onchecking: (ev: Event) => any;
+ onnoupdate: (ev: Event) => any;
+ swapCache(): void;
+ abort(): void;
+ update(): void;
+ CHECKING: number;
+ UNCACHED: number;
+ UPDATEREADY: number;
+ DOWNLOADING: number;
+ IDLE: number;
+ OBSOLETE: number;
+}
+declare var ApplicationCache: {
+ prototype: ApplicationCache;
+ new(): ApplicationCache;
+ CHECKING: number;
+ UNCACHED: number;
+ UPDATEREADY: number;
+ DOWNLOADING: number;
+ IDLE: number;
+ OBSOLETE: number;
+}
+
+interface MSHTMLVideoElementExtensions {
+ msIsStereo3D: bool;
+ msStereo3DPackingMode: string;
+ onMSVideoOptimalLayoutChanged: (ev: any) => any;
+ onMSVideoFrameStepCompleted: (ev: any) => any;
+ msStereo3DRenderMode: string;
+ msIsLayoutOptimalForPlayback: bool;
+ msHorizontalMirror: bool;
+ onMSVideoFormatChanged: (ev: any) => any;
+ msZoom: bool;
+ msInsertVideoEffect(activatableClassId: string, effectRequired: bool, config?: any): void;
+ msSetVideoRectangle(left: number, top: number, right: number, bottom: number): void;
+ msFrameStep(forward: bool): void;
+}
+
+interface FrameRequestCallback {
+ (time: number): void;
+}
+
+interface CSS3DTransformsProperties {
+ perspective: string;
+ msBackfaceVisibility: string;
+ perspectiveOrigin: string;
+ transformStyle: string;
+ backfaceVisibility: string;
+ msPerspectiveOrigin: string;
+ msTransformStyle: string;
+ msPerspective: string;
+}
+
+interface XMLHttpRequest {
+ withCredentials: bool;
+}
+
+interface PopStateEvent extends Event {
+ state: any;
+ initPopStateEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, stateArg: any): void;
+}
+declare var PopStateEvent: {
+ prototype: PopStateEvent;
+ new(): PopStateEvent;
+}
+
+interface CSSKeyframeRule extends CSSRule {
+ keyText: string;
+ style: CSSStyleDeclaration;
+}
+declare var CSSKeyframeRule: {
+ prototype: CSSKeyframeRule;
+ new(): CSSKeyframeRule;
+}
+
+interface CSSGridProperties {
+ msGridRows: string;
+ msGridColumnSpan: any;
+ msGridRow: any;
+ msGridRowSpan: any;
+ msGridColumns: string;
+ msGridColumnAlign: string;
+ msGridRowAlign: string;
+ msGridColumn: any;
+}
+
+interface MSFileSaver {
+ msSaveBlob(blob: any, defaultName?: string): bool;
+ msSaveOrOpenBlob(blob: any, defaultName?: string): bool;
+}
+
+interface MSStream {
+ type: string;
+ msDetachStream(): any;
+ msClose(): void;
+}
+declare var MSStream: {
+ prototype: MSStream;
+ new(): MSStream;
+}
+
+interface MediaError extends MSMediaErrorExtensions {
+}
+
+interface HTMLFieldSetElement {
+ validationMessage: string;
+ validity: ValidityState;
+ willValidate: bool;
+ checkValidity(): bool;
+ setCustomValidity(error: string): void;
+}
+
+interface MSBlobBuilder {
+ append(data: any, endings?: string): void;
+ getBlob(contentType?: string): Blob;
+}
+declare var MSBlobBuilder: {
+ prototype: MSBlobBuilder;
+ new (): MSBlobBuilder;
+}
+
+interface MSRangeExtensions {
+ createContextualFragment(fragment: string): DocumentFragment;
+}
+
+interface HTMLElement {
+ oncuechange: (ev: Event) => any;
+ spellcheck: bool;
+ classList: DOMTokenList;
+ draggable: bool;
+}
+
+interface DataTransfer {
+ types: DOMStringList;
+ files: FileList;
+}
+
+interface DOMSettableTokenList extends DOMTokenList {
+ value: string;
+}
+declare var DOMSettableTokenList: {
+ prototype: DOMSettableTokenList;
+ new(): DOMSettableTokenList;
+}
+
+interface IDBFactory {
+ open(name: string, version?: number): IDBOpenDBRequest;
+ cmp(first: any, second: any): number;
+ deleteDatabase(name: string): IDBOpenDBRequest;
+}
+declare var IDBFactory: {
+ prototype: IDBFactory;
+ new(): IDBFactory;
+}
+
+interface Range extends MSRangeExtensions {
+}
+
+interface HTMLObjectElement {
+ validationMessage: string;
+ validity: ValidityState;
+ willValidate: bool;
+ checkValidity(): bool;
+ setCustomValidity(error: string): void;
+}
+
+interface MSPointerEvent extends MouseEvent {
+ width: number;
+ rotation: number;
+ pressure: number;
+ pointerType: number;
+ isPrimary: bool;
+ tiltY: number;
+ height: number;
+ intermediatePoints: any;
+ currentPoint: any;
+ tiltX: number;
+ hwTimestamp: number;
+ pointerId: number;
+ initPointerEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: bool, altKeyArg: bool, shiftKeyArg: bool, metaKeyArg: bool, buttonArg: number, relatedTargetArg: EventTarget, offsetXArg: number, offsetYArg: number, widthArg: number, heightArg: number, pressure: number, rotation: number, tiltX: number, tiltY: number, pointerIdArg: number, pointerType: number, hwTimestampArg: number, isPrimary: bool): void;
+ getCurrentPoint(element: Element): void;
+ getIntermediatePoints(element: Element): void;
+ MSPOINTER_TYPE_PEN: number;
+ MSPOINTER_TYPE_MOUSE: number;
+ MSPOINTER_TYPE_TOUCH: number;
+}
+declare var MSPointerEvent: {
+ prototype: MSPointerEvent;
+ new(): MSPointerEvent;
+ MSPOINTER_TYPE_PEN: number;
+ MSPOINTER_TYPE_MOUSE: number;
+ MSPOINTER_TYPE_TOUCH: number;
+}
+
+interface CSSTextProperties {
+ textShadow: string;
+ msHyphenateLimitLines: any;
+ msHyphens: string;
+ msHyphenateLimitChars: string;
+ msHyphenateLimitZone: any;
+}
+
+interface CSS2DTransformsProperties {
+ transform: string;
+ transformOrigin: string;
+}
+
+interface DOMException {
+ name: string;
+ INVALID_NODE_TYPE_ERR: number;
+ DATA_CLONE_ERR: number;
+ TIMEOUT_ERR: number;
+}
+//declare var DOMException: {
+// INVALID_NODE_TYPE_ERR: number;
+// DATA_CLONE_ERR: number;
+// TIMEOUT_ERR: number;
+//}
+
+interface MSCSSHighContrastProperties {
+ msHighContrastAdjust: string;
+}
+
+interface MSManipulationEvent extends UIEvent {
+ lastState: number;
+ currentState: number;
+ initMSManipulationEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, lastState: number, currentState: number): void;
+ MS_MANIPULATION_STATE_STOPPED: number;
+ MS_MANIPULATION_STATE_ACTIVE: number;
+ MS_MANIPULATION_STATE_INERTIA: number;
+}
+declare var MSManipulationEvent: {
+ prototype: MSManipulationEvent;
+ new(): MSManipulationEvent;
+ MS_MANIPULATION_STATE_STOPPED: number;
+ MS_MANIPULATION_STATE_ACTIVE: number;
+ MS_MANIPULATION_STATE_INERTIA: number;
+}
+
+interface FormData {
+ append(name: any, value: any, blobName?: string): void;
+}
+declare var FormData: {
+ prototype: FormData;
+ new (): FormData;
+ new (form: HTMLFormElement): FormData;
+}
+
+interface MSHTMLImageElementExtensions {
+ msPlayToPrimary: bool;
+ msPlayToDisabled: bool;
+ msPlayToSource: any;
+}
+declare var MSHTMLImageElementExtensions: {
+ prototype: MSHTMLImageElementExtensions;
+ new(): MSHTMLImageElementExtensions;
+}
+
+interface MSHTMLMediaElementExtensions {
+ msAudioCategory: string;
+ msRealTime: bool;
+ msPlayToPrimary: bool;
+ msPlayToDisabled: bool;
+ msPlayToSource: any;
+ msAudioDeviceType: string;
+ msClearEffects(): void;
+ msSetMediaProtectionManager(mediaProtectionManager?: any): void;
+ msInsertAudioEffect(activatableClassId: string, effectRequired: bool, config?: any): void;
+}
+
+interface SVGFEImageElement extends SVGElement, SVGLangSpace, SVGFilterPrimitiveStandardAttributes, SVGURIReference {
+ preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
+}
+declare var SVGFEImageElement: {
+ prototype: SVGFEImageElement;
+ new(): SVGFEImageElement;
+}
+
+interface HTMLDataListElement extends HTMLElement {
+ options: HTMLCollection;
+}
+declare var HTMLDataListElement: {
+ prototype: HTMLDataListElement;
+ new(): HTMLDataListElement;
+}
+
+interface AbstractWorker extends EventTarget {
+ onerror: (ev: ErrorEvent) => any;
+}
+
+interface SVGFECompositeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ operator: SVGAnimatedEnumeration;
+ in2: SVGAnimatedString;
+ k2: SVGAnimatedNumber;
+ k1: SVGAnimatedNumber;
+ k3: SVGAnimatedNumber;
+ in1: SVGAnimatedString;
+ k4: SVGAnimatedNumber;
+ SVG_FECOMPOSITE_OPERATOR_OUT: number;
+ SVG_FECOMPOSITE_OPERATOR_OVER: number;
+ SVG_FECOMPOSITE_OPERATOR_XOR: number;
+ SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
+ SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
+ SVG_FECOMPOSITE_OPERATOR_IN: number;
+ SVG_FECOMPOSITE_OPERATOR_ATOP: number;
+}
+declare var SVGFECompositeElement: {
+ prototype: SVGFECompositeElement;
+ new(): SVGFECompositeElement;
+ SVG_FECOMPOSITE_OPERATOR_OUT: number;
+ SVG_FECOMPOSITE_OPERATOR_OVER: number;
+ SVG_FECOMPOSITE_OPERATOR_XOR: number;
+ SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number;
+ SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number;
+ SVG_FECOMPOSITE_OPERATOR_IN: number;
+ SVG_FECOMPOSITE_OPERATOR_ATOP: number;
+}
+
+interface ValidityState {
+ customError: bool;
+ valueMissing: bool;
+ stepMismatch: bool;
+ rangeUnderflow: bool;
+ rangeOverflow: bool;
+ typeMismatch: bool;
+ patternMismatch: bool;
+ tooLong: bool;
+ valid: bool;
+}
+declare var ValidityState: {
+ prototype: ValidityState;
+ new(): ValidityState;
+}
+
+interface HTMLVideoElement extends MSHTMLVideoElementExtensions {
+}
+
+interface HTMLTrackElement extends HTMLElement {
+ kind: string;
+ src: string;
+ srclang: string;
+ track: TextTrack;
+ label: string;
+ defaul: bool;
+}
+declare var HTMLTrackElement: {
+ prototype: HTMLTrackElement;
+ new(): HTMLTrackElement;
+}
+
+interface MSApp {
+ createFileFromStorageFile(storageFile: any): File;
+ createBlobFromRandomAccessStream(type: string, seeker: any): Blob;
+ createStreamFromInputStream(type: string, inputStream: any): MSStream;
+ terminateApp(exceptionObject: any): void;
+ createDataPackage(object: any): any;
+ execUnsafeLocalFunction(unsafeFunction: MSUnsafeFunctionCallback): any;
+ getHtmlPrintDocumentSource(htmlDoc: any, printTemplate?: string): any;
+ addPublicLocalApplicationUri(uri: string): void;
+ createDataPackageFromSelection(): any;
+}
+declare var MSApp: MSApp;
+
+interface MSXMLHttpRequestExtensions {
+ response: any;
+ onprogress: (ev: ProgressEvent) => any;
+ onabort: (ev: any) => any;
+ responseType: string;
+ onloadend: (ev: ProgressEvent) => any;
+ upload: XMLHttpRequestEventTarget;
+ onerror: (ev: ErrorEvent) => any;
+ onloadstart: (ev: any) => any;
+}
+declare var MSXMLHttpRequestExtensions: {
+ prototype: MSXMLHttpRequestExtensions;
+ new(): MSXMLHttpRequestExtensions;
+}
+
+interface SVGFEDiffuseLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ kernelUnitLengthY: SVGAnimatedNumber;
+ surfaceScale: SVGAnimatedNumber;
+ in1: SVGAnimatedString;
+ kernelUnitLengthX: SVGAnimatedNumber;
+ diffuseConstant: SVGAnimatedNumber;
+}
+declare var SVGFEDiffuseLightingElement: {
+ prototype: SVGFEDiffuseLightingElement;
+ new(): SVGFEDiffuseLightingElement;
+}
+
+interface SVGFEComponentTransferElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
+ in1: SVGAnimatedString;
+}
+declare var SVGFEComponentTransferElement: {
+ prototype: SVGFEComponentTransferElement;
+ new(): SVGFEComponentTransferElement;
+}
+
+interface MSCSSMatrix {
+ m24: number;
+ m34: number;
+ a: number;
+ d: number;
+ m32: number;
+ m41: number;
+ m11: number;
+ f: number;
+ e: number;
+ m23: number;
+ m14: number;
+ m33: number;
+ m22: number;
+ m21: number;
+ c: number;
+ m12: number;
+ b: number;
+ m42: number;
+ m31: number;
+ m43: number;
+ m13: number;
+ m44: number;
+ multiply(secondMatrix: MSCSSMatrix): MSCSSMatrix;
+ skewY(angle: number): MSCSSMatrix;
+ setMatrixValue(value: string): void;
+ inverse(): MSCSSMatrix;
+ rotateAxisAngle(x: number, y: number, z: number, angle: number): MSCSSMatrix;
+ toString(): string;
+ rotate(angleX: number, angleY?: number, angleZ?: number): MSCSSMatrix;
+ translate(x: number, y: number, z?: number): MSCSSMatrix;
+ scale(scaleX: number, scaleY?: number, scaleZ?: number): MSCSSMatrix;
+ skewX(angle: number): MSCSSMatrix;
+}
+declare var MSCSSMatrix: {
+ prototype: MSCSSMatrix;
+ new (text?: string): MSCSSMatrix;
+}
+
+interface Worker extends AbstractWorker {
+ onmessage: (ev: any) => any;
+ postMessage(message: any, ports?: any): void;
+ terminate(): void;
+}
+declare var Worker: {
+ prototype: Worker;
+ new (stringUrl: string): Worker;
+}
+
+interface HTMLIFrameElement {
+ sandbox: DOMSettableTokenList;
+}
+
+interface MSMediaErrorExtensions {
+ msExtendedCode: number;
+}
+
+interface MSNavigatorAbilities {
+ msProtocols: MSProtocolsCollection;
+ msMaxTouchPoints: number;
+ msPointerEnabled: bool;
+ msManipulationViewsEnabled: bool;
+}
+declare var MSNavigatorAbilities: {
+ prototype: MSNavigatorAbilities;
+ new(): MSNavigatorAbilities;
+}
+
+declare var onpopstate: (ev: PopStateEvent) => any;
+declare var applicationCache: ApplicationCache;
+declare function matchMedia(mediaQuery: string): MediaQueryList;
+declare function msMatchMedia(mediaQuery: string): MediaQueryList;
+declare var animationStartTime: number;
+declare var msAnimationStartTime: number;
+declare function msCancelRequestAnimationFrame(handle: number): void;
+declare function cancelAnimationFrame(handle: number): void;
+declare function requestAnimationFrame(callback: FrameRequestCallback): number;
+declare function msRequestAnimationFrame(callback: FrameRequestCallback): number;
+declare function btoa(rawString: string): string;
+declare function atob(encodedString: string): string;
+declare var msIndexedDB: IDBFactory;
+declare var indexedDB: IDBFactory;
+declare var console: Console;
+
+
+/////////////////////////////
+/// WorkerGlobalScope APIs
+/////////////////////////////
+// TODO: These are only available in a Web Worker - should be in a seperate lib file
+declare function importScripts(...urls: string[]): void;
+
+
+/////////////////////////////
+/// Windows Script Host APIS
+/////////////////////////////
+declare var ActiveXObject: { new (s: string): any; };
+
+interface ITextWriter {
+ Write(s: string): void;
+ WriteLine(s: string): void;
+ Close(): void;
+}
+
+declare var WScript : {
+ Echo(s);
+ StdErr: ITextWriter;
+ StdOut: ITextWriter;
+ Arguments: { length: number; Item(n: number): string; };
+ ScriptFullName: string;
+ Quit(exitCode?: number);
+}
+
diff --git a/bin/main.js b/bin/main.js
new file mode 100644
index 0000000..ded5066
--- /dev/null
+++ b/bin/main.js
@@ -0,0 +1,34383 @@
+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;
+ var BufferedTextWriter = (function () {
+ function BufferedTextWriter(writer, capacity) {
+ if (typeof capacity === "undefined") { capacity = 1024; }
+ this.writer = writer;
+ this.capacity = capacity;
+ this.buffer = "";
+ }
+ BufferedTextWriter.prototype.Write = function (str) {
+ this.buffer += str;
+ if(this.buffer.length >= this.capacity) {
+ this.writer.Write(this.buffer);
+ this.buffer = "";
+ }
+ };
+ BufferedTextWriter.prototype.WriteLine = function (str) {
+ this.Write(str + '\r\n');
+ };
+ BufferedTextWriter.prototype.Close = function () {
+ this.writer.Write(this.buffer);
+ this.writer.Close();
+ this.buffer = null;
+ };
+ return BufferedTextWriter;
+ })();
+ IOUtils.BufferedTextWriter = BufferedTextWriter;
+})(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) == 0xFE && bomChar.charCodeAt(1) == 0xFF) || (bomChar.charCodeAt(0) == 0xFF && bomChar.charCodeAt(1) == 0xFE)) {
+ streamObj.Charset = 'unicode';
+ } else if(bomChar.charCodeAt(0) == 0xEF && bomChar.charCodeAt(1) == 0xBB) {
+ 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 0xFE:
+ if(buffer[1] == 0xFF) {
+ 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 0xFF:
+ if(buffer[1] == 0xFE) {
+ return buffer.toString("ucs2", 2);
+ }
+ break;
+ case 0xEF:
+ if(buffer[1] == 0xBB) {
+ 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, 0775);
+ }
+ }
+ mkdirRecursiveSync(_path.dirname(path));
+ try {
+ var fd = _fs.openSync(path, 'w');
+ } catch (e) {
+ IOUtils.throwIOError("Couldn't write to file '" + path + "'.", e);
+ }
+ return new IOUtils.BufferedTextWriter({
+ Write: function (str) {
+ _fs.writeSync(fd, str);
+ },
+ 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 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 0x09:
+ result += "\\t";
+ break;
+ case 0x0a:
+ result += "\\n";
+ break;
+ case 0x0b:
+ result += "\\v";
+ break;
+ case 0x0c:
+ result += "\\f";
+ break;
+ case 0x0d:
+ result += "\\r";
+ break;
+ case 0x22:
+ result += "\\\"";
+ break;
+ case 0x27:
+ result += "\\\'";
+ break;
+ case 0x5c:
+ 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 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.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 = 0x27d4eb2d;
+ 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, text) {
+ _super.call(this, TypeScript.NodeType.NumberLit);
+ this.value = value;
+ this.text = text;
+ }
+ 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);
+ emitter.writeToOutput(this.text);
+ emitter.recordSourceMappingEnd(this);
+ emitter.emitParensAndCommentsInPlace(this, false);
+ };
+ NumberLiteral.prototype.printLabel = function () {
+ return this.text;
+ };
+ return NumberLiteral;
+ })(Expression);
+ TypeScript.NumberLiteral = NumberLiteral;
+ var RegexLiteral = (function (_super) {
+ __extends(RegexLiteral, _super);
+ function RegexLiteral(text) {
+ _super.call(this, TypeScript.NodeType.Regex);
+ this.text = text;
+ }
+ 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.text);
+ 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.isInlineCallLiteral = false;
+ this.accessorSymbol = null;
+ this.leftCurlyCount = 0;
+ this.rightCurlyCount = 0;
+ this.returnStatementsWithExpressions = [];
+ this.scopeType = null;
+ this.endingToken = null;
+ this.constructorSpan = 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;
+ }
+ 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) {
+ if(this.bod.members.length == 0) {
+ return this.setCachedEmitRequired(true);
+ }
+ 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.emitJavascriptList(this.bod, null, TypeScript.TokenID.Semicolon, true, false, false, true, this.requiresExtendsBlock);
+ }
+ };
+ 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, 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.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.isWholeFile = function () {
+ return TypeScript.hasFlag(this.modFlags, TypeScript.ModuleFlags.IsWholeFile);
+ };
+ 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.emitJavascriptModule(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;
+ this.colonSpan = new ASTSpan();
+ }
+ 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.recordSourceMappingStart(this.colonSpan);
+ emitter.writeToOutput(":");
+ emitter.recordSourceMappingEnd(this.colonSpan);
+ 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) == "*" && this.content.charAt(3) != "/";
+ }
+ 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.getDocCommentFirstOverloadSignature = function getDocCommentFirstOverloadSignature(signatureGroup) {
+ for(var i = 0; i < signatureGroup.signatures.length; i++) {
+ var signature = signatureGroup.signatures[i];
+ if(signature == signatureGroup.definitionSignature) {
+ continue;
+ }
+ return TypeScript.Comment.getDocCommentText(signature.declAST.getDocComments());
+ }
+ return "";
+ };
+ 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.writeToOutput("debugger");
+ emitter.recordSourceMappingEnd(this);
+ emitter.writeLineToOutput(";");
+ 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 && (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 && (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);
+ }
+ var callAndConstructScope = scope;
+ 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);
+ }
+ if(type.isModuleType()) {
+ callAndConstructScope = agg;
+ }
+ this.checker.currentModDecl = prevCurrentModDecl;
+ this.checker.inBind = prevBindStatus;
+ }
+ if(type.extendsTypeLinks) {
+ this.resolveBases(scope, type);
+ }
+ if(type.construct) {
+ this.resolveSignatureGroup(type.construct, callAndConstructScope, instanceType);
+ }
+ if(type.call) {
+ this.resolveSignatureGroup(type.call, callAndConstructScope, 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 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
+ });
+ };
+ }
+})());
+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, emitFullPathOfSourceMap) {
+ 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);
+ if(emitFullPathOfSourceMap) {
+ if(jsFileName.indexOf("://") == -1) {
+ jsFileName = "file:///" + jsFileName;
+ }
+ this.jsFileName = jsFileName;
+ }
+ 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;
+ }
+ 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;
+ this.emitFullSourceMapPath = settings.emitFullSourceMapPath;
+ }
+ 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.globalThisCapturePrologueEmitted = false;
+ this.extendsPrologueEmitted = 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) {
+ var text = comment.getText();
+ var hadNewLine = false;
+ if(comment.isBlockComment) {
+ if(this.emitState.column == 0) {
+ this.emitIndent();
+ }
+ this.recordSourceMappingStart(comment);
+ this.writeToOutput(text[0]);
+ if(text.length > 1 || comment.endsLine) {
+ for(var i = 1; i < text.length; i++) {
+ this.writeLineToOutput("");
+ this.emitIndent();
+ this.writeToOutput(text[i]);
+ }
+ this.recordSourceMappingEnd(comment);
+ this.writeLineToOutput("");
+ hadNewLine = true;
+ } else {
+ this.recordSourceMappingEnd(comment);
+ }
+ } else {
+ if(this.emitState.column == 0) {
+ this.emitIndent();
+ }
+ this.recordSourceMappingStart(comment);
+ this.writeToOutput(text[0]);
+ this.recordSourceMappingEnd(comment);
+ this.writeLineToOutput("");
+ hadNewLine = true;
+ }
+ if(hadNewLine) {
+ this.emitIndent();
+ } else {
+ this.writeToOutput(" ");
+ }
+ };
+ 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.getConstantValue = function (init) {
+ if(init) {
+ if(init.nodeType === TypeScript.NodeType.NumberLit) {
+ var numLit = init;
+ return numLit.value;
+ } else if(init.nodeType === TypeScript.NodeType.Lsh) {
+ var binop = init;
+ if(binop.operand1.nodeType === TypeScript.NodeType.NumberLit && binop.operand2.nodeType === TypeScript.NodeType.NumberLit) {
+ return (binop.operand1).value << (binop.operand2).value;
+ }
+ } else if(init.nodeType === TypeScript.NodeType.Name) {
+ var ident = init;
+ if(ident.sym !== null && ident.sym.declAST.nodeType === TypeScript.NodeType.VarDecl) {
+ var varDecl = ident.sym.declAST;
+ return this.getConstantValue(varDecl.init);
+ }
+ }
+ }
+ return null;
+ };
+ 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;
+ var value = this.getConstantValue(boundDecl.init);
+ if(value !== null) {
+ this.writeToOutput(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.Signature) || 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.emitOptions.emitFullSourceMapPath));
+ 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.writeToOutput(")(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.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));");
+ } else if(!isExported && temp != EmitContainer.Prog) {
+ this.writeToOutput("}");
+ if(!isWholeFile) {
+ this.recordSourceMappingNameEnd();
+ }
+ this.recordSourceMappingEnd(moduleDecl.endingToken);
+ this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));");
+ } else {
+ this.writeToOutput("}");
+ if(!isWholeFile) {
+ this.recordSourceMappingNameEnd();
+ }
+ this.recordSourceMappingEnd(moduleDecl.endingToken);
+ this.writeToOutput(")();");
+ }
+ this.recordSourceMappingEnd(moduleDecl);
+ this.writeLineToOutput("");
+ 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.Signature)) {
+ 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 isSingleQuotedMod = TypeScript.isSingleQuoted(modPath);
+ 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);
+ if(isSingleQuotedMod) {
+ modPath = TypeScript.changeToSingleQuote(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[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;
+ this.emitParensAndCommentsInPlace(ast, true);
+ if(list.members.length == 0) {
+ this.emitParensAndCommentsInPlace(ast, false);
+ return;
+ }
+ 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.extendsPrologueEmitted) {
+ if(reqInherits) {
+ this.extendsPrologueEmitted = 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.globalThisCapturePrologueEmitted) {
+ if(this.checker.mustCaptureGlobalThis) {
+ this.globalThisCapturePrologueEmitted = 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;
+ 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.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;
+ var memberNames = [];
+ 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;
+ memberNames.push(memberName);
+ } 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, "0");
+ lastValue = memberValue;
+ } else {
+ var nextValue = lastValue.value + 1;
+ memberValue = new TypeScript.NumberLiteral(nextValue, nextValue.toString());
+ 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;
+ } else if(memberValue.nodeType === TypeScript.NodeType.Lsh) {
+ var binop = memberValue;
+ if(binop.operand1.nodeType === TypeScript.NodeType.NumberLit && binop.operand2.nodeType === TypeScript.NodeType.NumberLit) {
+ member.varFlags |= TypeScript.VarFlags.Constant;
+ }
+ } else if(memberValue.nodeType === TypeScript.NodeType.Name) {
+ var nameNode = memberValue;
+ for(var i = 0; i < memberNames.length; i++) {
+ var memberName = memberNames[i];
+ if(memberName.text === nameNode.text) {
+ member.varFlags |= TypeScript.VarFlags.Constant;
+ break;
+ }
+ }
+ }
+ 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(), 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(), 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(), 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(), endingToken);
+ } else {
+ moduleDecl = new TypeScript.ModuleDeclaration(name, moduleBody, this.topVarList(), 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.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;
+ if(bod.limChar > bod.minChar) {
+ 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.limChar = retExpr.limChar;
+ bod.append(retStmt);
+ } else if(this.currentToken.tokenId != TypeScript.TokenID.EndOfFile) {
+ 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.Signature;
+ }
+ 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;
+ opArg.isParenthesized = false;
+ 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);
+ formals.minChar = preProcessedLambdaArgs.minChar;
+ 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.currentToken.tokenId == TypeScript.TokenID.EndOfFile ? this.scanner.pos : 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 && !methodName) {
+ this.currentToken = this.scanner.scan();
+ 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;
+ }
+ }
+ 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);
+ }
+ 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");
+ }
+ if(isLambda && this.currentToken.tokenId != TypeScript.TokenID.EqualsGreaterThan) {
+ this.reportParseError("Expected '=>'");
+ }
+ if(isDecl && !(this.parsingDeclareFile || markedAsAmbient) && !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(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 > 0xffff) {
+ 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(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();
+ var constructorSpan = new TypeScript.ASTSpan();
+ constructorSpan.minChar = this.scanner.startPos;
+ constructorSpan.limChar = this.scanner.pos;
+ 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.constructorSpan = constructorSpan;
+ 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, unnamedAmbientFunctionOk) {
+ 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;
+ }
+ if(!text && unnamedAmbientFunctionOk && !isIndexer) {
+ text = new TypeScript.MissingIdentifier();
+ }
+ var ast = this.parseFncDecl(ers, true, requireSignature, this.currentClassDefinition || this.inInterfaceDecl, 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 || (text.isMissing() && unnamedAmbientFunctionOk && !isIndexer)) {
+ 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:
+ 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.currentToken.tokenId == TypeScript.TokenID.EndOfFile ? this.scanner.pos : 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.currentToken.tokenId == TypeScript.TokenID.EndOfFile ? this.scanner.pos : 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.text);
+ 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.text);
+ 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);
+ 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());
+ if(preComments) {
+ ast.preComments = ast.preComments ? preComments.concat(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.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();
+ 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, true);
+ 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(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported) || 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, false, 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);
+ 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;
+ break;
+ default:
+ temp = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon | TypeScript.ErrorRecoverySet.In, TypeScript.OperatorPrecedence.None, false, TypeContext.NoTypes);
+ break;
+ }
+ 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);
+ }
+ caseStmt.colonSpan.minChar = this.scanner.startPos;
+ caseStmt.colonSpan.limChar = this.scanner.pos;
+ 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 = ast.preComments ? preComments.concat(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).bod == null));
+ };
+ 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;
+ 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)) {
+ 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.fname = filename;
+ this.currentUnitIndex = unitIndex;
+ this.currentToken = null;
+ this.needTerminator = false;
+ this.inFunction = false;
+ this.inInterfaceDecl = false;
+ this.inFncDecl = false;
+ this.ambientModule = false;
+ this.ambientClass = false;
+ this.topLevel = true;
+ this.allowImportDeclaration = true;
+ 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.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.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();
+ }
+ 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(), 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 = 0x0A;
+ TypeScript.LexCodeRET = 0x0D;
+ TypeScript.LexCodeLS = 0x2028;
+ TypeScript.LexCodePS = 0x2029;
+ TypeScript.LexCodeTAB = 0x09;
+ TypeScript.LexCodeVTAB = 0x0B;
+ 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,
+ 19893,
+ 19968,
+ 40869,
+ 40960,
+ 42124,
+ 44032,
+ 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,
+ 19893,
+ 19968,
+ 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,
+ 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.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.lastTokenLimChar = function () {
+ if(this.prevSavedToken !== null) {
+ return this.prevSavedToken.limChar;
+ } else {
+ return 0;
+ }
+ };
+ SavedTokens.prototype.lastTokenHadNewline = function () {
+ return this.prevLine != this.startLine;
+ };
+ 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.setText = function (newSrc, textMode) {
+ this.setSourceText(new StringSourceText(newSrc), textMode);
+ };
+ Scanner.prototype.setScanComments = function (value) {
+ this.scanComments = value;
+ };
+ 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseInt(text), text);
+ } else {
+ return null;
+ }
+ }
+ }
+ };
+ Scanner.prototype.scanOctalDigits = function () {
+ var atLeastOneDigit = false;
+ for(; ; ) {
+ if(this.IsOctalDigit(this.ch)) {
+ this.nextChar();
+ atLeastOneDigit = true;
+ } else {
+ if(atLeastOneDigit) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseInt(text), text);
+ } 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ } 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ } 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ } else {
+ if(!atLeastOneDigit) {
+ this.pos = svPos;
+ this.col = svCol;
+ return null;
+ } else {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ }
+ }
+ } else {
+ if(!atLeastOneDigit) {
+ this.pos = svPos;
+ this.col = svCol;
+ return null;
+ } else {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ }
+ }
+ }
+ };
+ 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.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(this.src.substring(svPos - 1, this.pos));
+ }
+ }
+ 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 = this.peekChar();
+ this.lexState = LexState.Start;
+ return this.scanStringConstant(TypeScript.LexCodeAPO);
+ } else if(this.lexState == LexState.InMultilineDoubleQuoteString && this.pos < this.len) {
+ this.ch = this.peekChar();
+ this.lexState = LexState.Start;
+ return this.scanStringConstant(TypeScript.LexCodeQUO);
+ }
+ 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 (endCode) {
+ 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.newLine();
+ if(this.mode == LexMode.Line) {
+ this.nextChar();
+ 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)) {
+ var endCode = this.ch;
+ this.nextChar();
+ return this.scanStringConstant(endCode);
+ } 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 0xFF:
+ case 0xFE:
+ case 0xEF:
+ case 0xBB:
+ case 0xBF:
+ 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) && !funcDecl.isAccessor()) {
+ 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);
+ } 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.Signature)) {
+ this.definitionSignature = signature;
+ }
+ };
+ SignatureGroup.prototype.toString = function () {
+ return this.signatures.toString();
+ };
+ SignatureGroup.prototype.toStrings = function (prefix, shortform, scope, getPrettyTypeName, useSignature) {
+ var _this = this;
+ var result = [];
+ var len = this.signatures.length;
+ if(!getPrettyTypeName && len > 1) {
+ shortform = false;
+ }
+ var getMemberNameOfSignature = function (signature) {
+ if(_this.flags & TypeScript.SignatureFlags.IsIndexer) {
+ return signature.toStringHelperEx(shortform, true, scope);
+ } else {
+ return signature.toStringHelperEx(shortform, false, scope, prefix);
+ }
+ };
+ if(useSignature) {
+ result.push(getMemberNameOfSignature(useSignature));
+ } else {
+ for(var i = 0; i < len; i++) {
+ if(len > 1 && this.signatures[i] == this.definitionSignature) {
+ continue;
+ }
+ result.push(getMemberNameOfSignature(this.signatures[i]));
+ if(getPrettyTypeName) {
+ break;
+ }
+ }
+ }
+ if(getPrettyTypeName && len > 1) {
+ var lastMemberName = result[result.length - 1];
+ var overloadString = " (+ " + ((this.definitionSignature != null) ? len - 2 : len - 1) + " overload(s))";
+ lastMemberName.add(TypeScript.MemberName.create(overloadString));
+ }
+ 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.Signature) && TypeScript.hasFlag(this.signatures[j].declAST.fncFlags, TypeScript.FncFlags.Signature)) && 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 (scope) {
+ var scopeSymbol = !scope ? null : scope.container;
+ var scopeRootPath = !scopeSymbol ? [] : scopeSymbol.pathToRoot();
+ var dynamicModuleRoot = null;
+ if(scopeRootPath.length > 0 && scopeRootPath[scopeRootPath.length - 1].declAST && scopeRootPath[scopeRootPath.length - 1].declAST.nodeType == TypeScript.NodeType.ModuleDeclaration && (scopeRootPath[scopeRootPath.length - 1].declAST).isWholeFile()) {
+ dynamicModuleRoot = scopeRootPath[scopeRootPath.length - 1];
+ }
+ var builder = this.getPrettyName(scopeSymbol);
+ var ancestor = this.container;
+ while(ancestor && (ancestor.name != TypeScript.globalId) && ancestor != dynamicModuleRoot) {
+ builder = ancestor.getPrettyName(scopeSymbol) + "." + 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 ? this.field.typeLink.type.getScopedTypeNameEx(scope) : TypeScript.MemberName.create("any"), 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;
+ };
+ ParameterSymbol.prototype.fullName = function () {
+ return this.name;
+ };
+ return ParameterSymbol;
+ })(InferenceSymbol);
+ TypeScript.ParameterSymbol = ParameterSymbol;
+ var VariableSymbol = (function (_super) {
+ __extends(VariableSymbol, _super);
+ function VariableSymbol(name, location, unitIndex, variable) {
+ _super.call(this, name, location, name.length, unitIndex);
+ this.variable = variable;
+ }
+ VariableSymbol.prototype.kind = function () {
+ return TypeScript.SymbolKind.Variable;
+ };
+ VariableSymbol.prototype.writeable = function () {
+ return true;
+ };
+ VariableSymbol.prototype.getType = function () {
+ return this.variable.typeLink.type;
+ };
+ VariableSymbol.prototype.getTypeNameEx = function (scope) {
+ return TypeScript.MemberName.create(this.getType().getScopedTypeNameEx(scope), this.name + ": ", "");
+ };
+ VariableSymbol.prototype.setType = function (type) {
+ this.variable.typeLink.type = type;
+ };
+ VariableSymbol.prototype.isVariable = function () {
+ return true;
+ };
+ return VariableSymbol;
+ })(InferenceSymbol);
+ TypeScript.VariableSymbol = VariableSymbol;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+ var ScopedMembers = (function () {
+ function ScopedMembers(dualMembers) {
+ this.dualMembers = dualMembers;
+ this.allMembers = this.dualMembers;
+ this.publicMembers = this.dualMembers.primaryTable;
+ this.privateMembers = this.dualMembers.secondaryTable;
+ }
+ ScopedMembers.prototype.addPublicMember = function (key, data) {
+ return this.dualMembers.primaryTable.add(key, data);
+ };
+ ScopedMembers.prototype.addPrivateMember = function (key, data) {
+ return this.dualMembers.secondaryTable.add(key, data);
+ };
+ return ScopedMembers;
+ })();
+ TypeScript.ScopedMembers = ScopedMembers;
+ (function (SymbolKind) {
+ SymbolKind._map = [];
+ SymbolKind._map[0] = "None";
+ SymbolKind.None = 0;
+ SymbolKind._map[1] = "Type";
+ SymbolKind.Type = 1;
+ SymbolKind._map[2] = "Field";
+ SymbolKind.Field = 2;
+ SymbolKind._map[3] = "Parameter";
+ SymbolKind.Parameter = 3;
+ SymbolKind._map[4] = "Variable";
+ SymbolKind.Variable = 4;
+ })(TypeScript.SymbolKind || (TypeScript.SymbolKind = {}));
+ var SymbolKind = TypeScript.SymbolKind;
+ var SymbolScope = (function () {
+ function SymbolScope(container) {
+ this.container = container;
+ }
+ SymbolScope.prototype.printLabel = function () {
+ return "base";
+ };
+ SymbolScope.prototype.getAllSymbolNames = function (members) {
+ return [
+ "please",
+ "implement",
+ "in",
+ "derived",
+ "classes"
+ ];
+ };
+ SymbolScope.prototype.getAllTypeSymbolNames = function (members) {
+ return [
+ "please",
+ "implement",
+ "in",
+ "derived",
+ "classes"
+ ];
+ };
+ SymbolScope.prototype.getAllValueSymbolNames = function (members) {
+ return [
+ "please",
+ "implement",
+ "in",
+ "derived",
+ "classes"
+ ];
+ };
+ SymbolScope.prototype.search = function (filter, name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.findLocal = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.find = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.findImplementation = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.findAmbient = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.print = function (outfile) {
+ if(this.container) {
+ outfile.WriteLine(this.printLabel() + " scope with container: " + this.container.name + "...");
+ } else {
+ outfile.WriteLine(this.printLabel() + " scope...");
+ }
+ };
+ SymbolScope.prototype.enter = function (container, ast, symbol, errorReporter, publicOnly, typespace, ambient) {
+ throw new Error("please implement in derived class");
+ };
+ SymbolScope.prototype.getTable = function () {
+ throw new Error("please implement in derived class");
+ };
+ return SymbolScope;
+ })();
+ TypeScript.SymbolScope = SymbolScope;
+ function symbolCanBeUsed(sym, publicOnly) {
+ return publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true;
+ }
+ var SymbolAggregateScope = (function (_super) {
+ __extends(SymbolAggregateScope, _super);
+ function SymbolAggregateScope(container) {
+ _super.call(this, container);
+ this.valueCache = null;
+ this.valueImplCache = null;
+ this.valueAmbientCache = null;
+ this.typeCache = null;
+ this.typeImplCache = null;
+ this.typeAmbientCache = null;
+ this.parents = null;
+ this.container = container;
+ }
+ SymbolAggregateScope.prototype.printLabel = function () {
+ return "agg";
+ };
+ SymbolAggregateScope.prototype.search = function (filter, name, publicOnly, typespace) {
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var sym = this.parents[i].search(filter, name, publicOnly, typespace);
+ if(sym) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ }
+ return filter.result;
+ };
+ SymbolAggregateScope.prototype.getAllSymbolNames = function (members) {
+ var result = [];
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var parentResult = this.parents[i].getAllSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ }
+ return result;
+ };
+ SymbolAggregateScope.prototype.getAllTypeSymbolNames = function (members) {
+ var result = [];
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var parentResult = this.parents[i].getAllTypeSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ }
+ return result;
+ };
+ SymbolAggregateScope.prototype.getAllValueSymbolNames = function (members) {
+ var result = [];
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var parentResult = this.parents[i].getAllValueSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ }
+ return result;
+ };
+ SymbolAggregateScope.prototype.print = function (outfile) {
+ _super.prototype.print.call(this, outfile);
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ this.parents[i].print(outfile);
+ }
+ }
+ };
+ SymbolAggregateScope.prototype.findImplementation = function (name, publicOnly, typespace) {
+ var sym = null;
+ var i = 0;
+ var implCache = this.valueImplCache;
+ if(typespace) {
+ implCache = this.typeImplCache;
+ }
+ if(implCache && ((sym = implCache.lookup(name)) != null) && (publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true)) {
+ return sym;
+ }
+ if(this.parents) {
+ for(i = 0; i < this.parents.length; i++) {
+ sym = this.parents[i].findImplementation(name, publicOnly, typespace);
+ if(sym) {
+ break;
+ }
+ }
+ }
+ if(implCache) {
+ if(typespace) {
+ this.typeImplCache = new TypeScript.StringHashTable();
+ implCache = this.typeImplCache;
+ } else {
+ this.valueImplCache = new TypeScript.StringHashTable();
+ implCache = this.valueImplCache;
+ }
+ }
+ implCache.add(name, sym);
+ return sym;
+ };
+ SymbolAggregateScope.prototype.find = function (name, publicOnly, typespace) {
+ var sym = null;
+ var i = 0;
+ var cache = this.valueCache;
+ if(typespace) {
+ cache = this.typeCache;
+ }
+ if(cache && ((sym = cache.lookup(name)) != null) && (publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true)) {
+ return sym;
+ }
+ if(this.parents) {
+ for(i = 0; i < this.parents.length; i++) {
+ sym = this.parents[i].find(name, publicOnly, typespace);
+ if(sym) {
+ break;
+ }
+ }
+ }
+ if(cache == null) {
+ if(typespace) {
+ this.typeCache = new TypeScript.StringHashTable();
+ cache = this.typeCache;
+ } else {
+ this.valueCache = new TypeScript.StringHashTable();
+ cache = this.valueCache;
+ }
+ }
+ cache.add(name, sym);
+ return sym;
+ };
+ SymbolAggregateScope.prototype.findAmbient = function (name, publicOnly, typespace) {
+ var sym = null;
+ var i = 0;
+ var cache = this.valueAmbientCache;
+ if(typespace) {
+ cache = this.typeAmbientCache;
+ }
+ if(cache && ((sym = cache.lookup(name)) != null)) {
+ return sym;
+ }
+ if(this.parents) {
+ for(i = 0; i < this.parents.length; i++) {
+ sym = this.parents[i].findAmbient(name, publicOnly, typespace);
+ if(sym) {
+ break;
+ }
+ }
+ }
+ if(cache == null) {
+ if(typespace) {
+ this.typeAmbientCache = new TypeScript.StringHashTable();
+ cache = this.typeAmbientCache;
+ } else {
+ this.valueAmbientCache = new TypeScript.StringHashTable();
+ cache = this.valueAmbientCache;
+ }
+ }
+ cache.add(name, sym);
+ return sym;
+ };
+ SymbolAggregateScope.prototype.addParentScope = function (parent) {
+ if(this.parents == null) {
+ this.parents = new Array();
+ }
+ this.parents[this.parents.length] = parent;
+ };
+ return SymbolAggregateScope;
+ })(SymbolScope);
+ TypeScript.SymbolAggregateScope = SymbolAggregateScope;
+ var SymbolTableScope = (function (_super) {
+ __extends(SymbolTableScope, _super);
+ function SymbolTableScope(valueMembers, ambientValueMembers, enclosedTypes, ambientEnclosedTypes, container) {
+ _super.call(this, container);
+ this.valueMembers = valueMembers;
+ this.ambientValueMembers = ambientValueMembers;
+ this.enclosedTypes = enclosedTypes;
+ this.ambientEnclosedTypes = ambientEnclosedTypes;
+ this.container = container;
+ }
+ SymbolTableScope.prototype.printLabel = function () {
+ return "table";
+ };
+ SymbolTableScope.prototype.getAllSymbolNames = function (members) {
+ var result = this.getAllTypeSymbolNames(members);
+ return result.concat(this.getAllValueSymbolNames(members));
+ };
+ SymbolTableScope.prototype.getAllTypeSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientEnclosedTypes) {
+ result = result.concat(this.ambientEnclosedTypes.allMembers.getAllKeys());
+ }
+ if(this.enclosedTypes) {
+ result = result.concat(this.enclosedTypes.allMembers.getAllKeys());
+ }
+ return result;
+ };
+ SymbolTableScope.prototype.getAllValueSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientValueMembers) {
+ result = result.concat(this.ambientValueMembers.allMembers.getAllKeys());
+ }
+ if(this.valueMembers) {
+ result = result.concat(this.valueMembers.allMembers.getAllKeys());
+ }
+ return result;
+ };
+ SymbolTableScope.prototype.search = function (filter, name, publicOnly, typespace) {
+ var sym = this.find(name, publicOnly, typespace);
+ filter.update(sym);
+ return filter.result;
+ };
+ SymbolTableScope.prototype.find = function (name, publicOnly, typespace) {
+ var table = null;
+ var ambientTable = null;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ } else {
+ table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ }
+ if(ambientTable) {
+ var s = ambientTable.lookup(name);
+ if(s) {
+ return s;
+ }
+ }
+ if(table) {
+ var s = table.lookup(name);
+ if(s) {
+ return s;
+ }
+ }
+ return null;
+ };
+ SymbolTableScope.prototype.findAmbient = function (name, publicOnly, typespace) {
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable) {
+ var s = ambientTable.lookup(name);
+ if(s) {
+ return s;
+ }
+ }
+ return null;
+ };
+ SymbolTableScope.prototype.print = function (outfile) {
+ _super.prototype.print.call(this, outfile);
+ if(this.ambientValueMembers) {
+ this.ambientValueMembers.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.valueMembers) {
+ this.valueMembers.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.ambientEnclosedTypes) {
+ this.ambientEnclosedTypes.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.enclosedTypes) {
+ this.enclosedTypes.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ };
+ SymbolTableScope.prototype.findImplementation = function (name, publicOnly, typespace) {
+ var sym = this.find(name, publicOnly, typespace);
+ if(sym) {
+ if(sym.kind() == SymbolKind.Type) {
+ var typeSym = sym;
+ if(!typeSym.type.hasImplementation()) {
+ sym = null;
+ }
+ } else if(sym.container) {
+ if(sym.container.kind() == SymbolKind.Type) {
+ var ctypeSym = sym.container;
+ if(!ctypeSym.type.hasImplementation()) {
+ sym = null;
+ }
+ }
+ }
+ }
+ return sym;
+ };
+ SymbolTableScope.prototype.getTable = function () {
+ return this.valueMembers.publicMembers;
+ };
+ return SymbolTableScope;
+ })(SymbolScope);
+ TypeScript.SymbolTableScope = SymbolTableScope;
+ var SymbolScopeBuilder = (function (_super) {
+ __extends(SymbolScopeBuilder, _super);
+ function SymbolScopeBuilder(valueMembers, ambientValueMembers, enclosedTypes, ambientEnclosedTypes, parent, container) {
+ _super.call(this, container);
+ this.valueMembers = valueMembers;
+ this.ambientValueMembers = ambientValueMembers;
+ this.enclosedTypes = enclosedTypes;
+ this.ambientEnclosedTypes = ambientEnclosedTypes;
+ this.parent = parent;
+ this.container = container;
+ }
+ SymbolScopeBuilder.prototype.printLabel = function () {
+ return "builder";
+ };
+ SymbolScopeBuilder.prototype.getAllSymbolNames = function (members) {
+ var result = this.getAllTypeSymbolNames(members);
+ return result.concat(this.getAllValueSymbolNames(members));
+ };
+ SymbolScopeBuilder.prototype.getAllTypeSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientEnclosedTypes) {
+ result = result.concat(this.ambientEnclosedTypes.allMembers.getAllKeys());
+ }
+ if(this.enclosedTypes) {
+ result = result.concat(this.enclosedTypes.allMembers.getAllKeys());
+ }
+ if(!members && this.parent) {
+ var parentResult = this.parent.getAllTypeSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ return result;
+ };
+ SymbolScopeBuilder.prototype.getAllValueSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientValueMembers) {
+ result = result.concat(this.ambientValueMembers.allMembers.getAllKeys());
+ }
+ if(this.valueMembers) {
+ result = result.concat(this.valueMembers.allMembers.getAllKeys());
+ }
+ if(!members && this.parent) {
+ var parentResult = this.parent.getAllValueSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ return result;
+ };
+ SymbolScopeBuilder.prototype.search = function (filter, name, publicOnly, typespace) {
+ var sym = null;
+ var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable) {
+ if((sym = ambientTable.lookup(name)) != null) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ if(table) {
+ if((sym = table.lookup(name)) != null) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ if(this.parent) {
+ sym = this.parent.search(filter, name, publicOnly, typespace);
+ if(sym) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ return filter.result;
+ };
+ SymbolScopeBuilder.prototype.print = function (outfile) {
+ _super.prototype.print.call(this, outfile);
+ if(this.ambientValueMembers) {
+ this.ambientValueMembers.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.valueMembers) {
+ this.valueMembers.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.ambientEnclosedTypes) {
+ this.ambientEnclosedTypes.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.enclosedTypes) {
+ this.enclosedTypes.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.parent) {
+ this.parent.print(outfile);
+ }
+ };
+ SymbolScopeBuilder.prototype.find = function (name, publicOnly, typespace) {
+ var sym = null;
+ var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable && ((sym = ambientTable.lookup(name)) != null)) {
+ return sym;
+ }
+ if(table && ((sym = table.lookup(name)) != null)) {
+ return sym;
+ }
+ if(this.parent) {
+ return this.parent.find(name, publicOnly, typespace);
+ }
+ return null;
+ };
+ SymbolScopeBuilder.prototype.findAmbient = function (name, publicOnly, typespace) {
+ var sym = null;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable && ((sym = ambientTable.lookup(name)) != null)) {
+ return sym;
+ }
+ if(this.parent) {
+ return this.parent.findAmbient(name, publicOnly, typespace);
+ }
+ return null;
+ };
+ SymbolScopeBuilder.prototype.findLocal = function (name, publicOnly, typespace) {
+ var sym = null;
+ var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(table) {
+ if((sym = table.lookup(name)) != null) {
+ if(sym) {
+ return sym;
+ }
+ }
+ }
+ if(ambientTable) {
+ if((sym = ambientTable.lookup(name)) != null) {
+ if(sym) {
+ return sym;
+ }
+ }
+ }
+ return null;
+ };
+ SymbolScopeBuilder.prototype.enter = function (container, ast, symbol, errorReporter, insertAsPublic, typespace, ambient) {
+ var table = null;
+ if(ambient) {
+ if(typespace) {
+ table = (this.ambientEnclosedTypes == null) ? null : insertAsPublic ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.privateMembers;
+ } else {
+ table = (this.ambientValueMembers == null) ? null : insertAsPublic ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.privateMembers;
+ }
+ } else {
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : insertAsPublic ? this.enclosedTypes.publicMembers : this.enclosedTypes.privateMembers;
+ } else {
+ table = (this.valueMembers == null) ? null : insertAsPublic ? this.valueMembers.publicMembers : this.valueMembers.privateMembers;
+ }
+ }
+ if(table) {
+ if(!table.add(symbol.name, symbol)) {
+ errorReporter.duplicateIdentifier(ast, symbol.name);
+ }
+ } else {
+ TypeScript.CompilerDiagnostics.Alert("YYYYY");
+ }
+ symbol.container = container;
+ };
+ SymbolScopeBuilder.prototype.getTable = function () {
+ return this.valueMembers.allMembers;
+ };
+ return SymbolScopeBuilder;
+ })(SymbolScope);
+ TypeScript.SymbolScopeBuilder = SymbolScopeBuilder;
+ var FilteredSymbolScope = (function (_super) {
+ __extends(FilteredSymbolScope, _super);
+ function FilteredSymbolScope(scope, container, filter) {
+ _super.call(this, container);
+ this.scope = scope;
+ this.filter = filter;
+ }
+ FilteredSymbolScope.prototype.print = function (outfile) {
+ this.scope.print(outfile);
+ };
+ FilteredSymbolScope.prototype.find = function (name, publicOnly, typespace) {
+ this.filter.reset();
+ return this.scope.search(this.filter, name, publicOnly, typespace);
+ };
+ FilteredSymbolScope.prototype.findLocal = function (name, publicOnly, typespace) {
+ return this.scope.findLocal(name, publicOnly, typespace);
+ };
+ return FilteredSymbolScope;
+ })(SymbolScope);
+ TypeScript.FilteredSymbolScope = FilteredSymbolScope;
+ var FilteredSymbolScopeBuilder = (function (_super) {
+ __extends(FilteredSymbolScopeBuilder, _super);
+ function FilteredSymbolScopeBuilder(valueMembers, parent, container, filter) {
+ _super.call(this, valueMembers, null, null, null, parent, container);
+ this.filter = filter;
+ }
+ FilteredSymbolScopeBuilder.prototype.findLocal = function (name, publicOnly, typespace) {
+ var sym = _super.prototype.findLocal.call(this, name, publicOnly, typespace);
+ if(sym) {
+ if(!this.filter(sym)) {
+ return null;
+ }
+ }
+ return sym;
+ };
+ FilteredSymbolScopeBuilder.prototype.search = function (filter, name, publicOnly, typespace) {
+ throw new Error("please implement");
+ };
+ FilteredSymbolScopeBuilder.prototype.find = function (name, publicOnly, typespace) {
+ var sym = _super.prototype.findLocal.call(this, name, publicOnly, typespace);
+ if(sym) {
+ if(!this.filter(sym)) {
+ return null;
+ }
+ }
+ return _super.prototype.find.call(this, name, publicOnly, typespace);
+ };
+ return FilteredSymbolScopeBuilder;
+ })(SymbolScopeBuilder);
+ TypeScript.FilteredSymbolScopeBuilder = FilteredSymbolScopeBuilder;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+ (function (TokenID) {
+ TokenID._map = [];
+ TokenID._map[0] = "Any";
+ TokenID.Any = 0;
+ TokenID._map[1] = "Bool";
+ TokenID.Bool = 1;
+ TokenID._map[2] = "Break";
+ TokenID.Break = 2;
+ TokenID._map[3] = "Case";
+ TokenID.Case = 3;
+ TokenID._map[4] = "Catch";
+ TokenID.Catch = 4;
+ TokenID._map[5] = "Class";
+ TokenID.Class = 5;
+ TokenID._map[6] = "Const";
+ TokenID.Const = 6;
+ TokenID._map[7] = "Continue";
+ TokenID.Continue = 7;
+ TokenID._map[8] = "Debugger";
+ TokenID.Debugger = 8;
+ TokenID._map[9] = "Default";
+ TokenID.Default = 9;
+ TokenID._map[10] = "Delete";
+ TokenID.Delete = 10;
+ TokenID._map[11] = "Do";
+ TokenID.Do = 11;
+ TokenID._map[12] = "Else";
+ TokenID.Else = 12;
+ TokenID._map[13] = "Enum";
+ TokenID.Enum = 13;
+ TokenID._map[14] = "Export";
+ TokenID.Export = 14;
+ TokenID._map[15] = "Extends";
+ TokenID.Extends = 15;
+ TokenID._map[16] = "Declare";
+ TokenID.Declare = 16;
+ TokenID._map[17] = "False";
+ TokenID.False = 17;
+ TokenID._map[18] = "Finally";
+ TokenID.Finally = 18;
+ TokenID._map[19] = "For";
+ TokenID.For = 19;
+ TokenID._map[20] = "Function";
+ TokenID.Function = 20;
+ TokenID._map[21] = "Constructor";
+ TokenID.Constructor = 21;
+ TokenID._map[22] = "Get";
+ TokenID.Get = 22;
+ TokenID._map[23] = "If";
+ TokenID.If = 23;
+ TokenID._map[24] = "Implements";
+ TokenID.Implements = 24;
+ TokenID._map[25] = "Import";
+ TokenID.Import = 25;
+ TokenID._map[26] = "In";
+ TokenID.In = 26;
+ TokenID._map[27] = "InstanceOf";
+ TokenID.InstanceOf = 27;
+ TokenID._map[28] = "Interface";
+ TokenID.Interface = 28;
+ TokenID._map[29] = "Let";
+ TokenID.Let = 29;
+ TokenID._map[30] = "Module";
+ TokenID.Module = 30;
+ TokenID._map[31] = "New";
+ TokenID.New = 31;
+ TokenID._map[32] = "Number";
+ TokenID.Number = 32;
+ TokenID._map[33] = "Null";
+ TokenID.Null = 33;
+ TokenID._map[34] = "Package";
+ TokenID.Package = 34;
+ TokenID._map[35] = "Private";
+ TokenID.Private = 35;
+ TokenID._map[36] = "Protected";
+ TokenID.Protected = 36;
+ TokenID._map[37] = "Public";
+ TokenID.Public = 37;
+ TokenID._map[38] = "Return";
+ TokenID.Return = 38;
+ TokenID._map[39] = "Set";
+ TokenID.Set = 39;
+ TokenID._map[40] = "Static";
+ TokenID.Static = 40;
+ TokenID._map[41] = "String";
+ TokenID.String = 41;
+ TokenID._map[42] = "Super";
+ TokenID.Super = 42;
+ TokenID._map[43] = "Switch";
+ TokenID.Switch = 43;
+ TokenID._map[44] = "This";
+ TokenID.This = 44;
+ TokenID._map[45] = "Throw";
+ TokenID.Throw = 45;
+ TokenID._map[46] = "True";
+ TokenID.True = 46;
+ TokenID._map[47] = "Try";
+ TokenID.Try = 47;
+ TokenID._map[48] = "TypeOf";
+ TokenID.TypeOf = 48;
+ TokenID._map[49] = "Var";
+ TokenID.Var = 49;
+ TokenID._map[50] = "Void";
+ TokenID.Void = 50;
+ TokenID._map[51] = "With";
+ TokenID.With = 51;
+ TokenID._map[52] = "While";
+ TokenID.While = 52;
+ TokenID._map[53] = "Yield";
+ TokenID.Yield = 53;
+ TokenID._map[54] = "Semicolon";
+ TokenID.Semicolon = 54;
+ TokenID._map[55] = "OpenParen";
+ TokenID.OpenParen = 55;
+ TokenID._map[56] = "CloseParen";
+ TokenID.CloseParen = 56;
+ TokenID._map[57] = "OpenBracket";
+ TokenID.OpenBracket = 57;
+ TokenID._map[58] = "CloseBracket";
+ TokenID.CloseBracket = 58;
+ TokenID._map[59] = "OpenBrace";
+ TokenID.OpenBrace = 59;
+ TokenID._map[60] = "CloseBrace";
+ TokenID.CloseBrace = 60;
+ TokenID._map[61] = "Comma";
+ TokenID.Comma = 61;
+ TokenID._map[62] = "Equals";
+ TokenID.Equals = 62;
+ TokenID._map[63] = "PlusEquals";
+ TokenID.PlusEquals = 63;
+ TokenID._map[64] = "MinusEquals";
+ TokenID.MinusEquals = 64;
+ TokenID._map[65] = "AsteriskEquals";
+ TokenID.AsteriskEquals = 65;
+ TokenID._map[66] = "SlashEquals";
+ TokenID.SlashEquals = 66;
+ TokenID._map[67] = "PercentEquals";
+ TokenID.PercentEquals = 67;
+ TokenID._map[68] = "AmpersandEquals";
+ TokenID.AmpersandEquals = 68;
+ TokenID._map[69] = "CaretEquals";
+ TokenID.CaretEquals = 69;
+ TokenID._map[70] = "BarEquals";
+ TokenID.BarEquals = 70;
+ TokenID._map[71] = "LessThanLessThanEquals";
+ TokenID.LessThanLessThanEquals = 71;
+ TokenID._map[72] = "GreaterThanGreaterThanEquals";
+ TokenID.GreaterThanGreaterThanEquals = 72;
+ TokenID._map[73] = "GreaterThanGreaterThanGreaterThanEquals";
+ TokenID.GreaterThanGreaterThanGreaterThanEquals = 73;
+ TokenID._map[74] = "Question";
+ TokenID.Question = 74;
+ TokenID._map[75] = "Colon";
+ TokenID.Colon = 75;
+ TokenID._map[76] = "BarBar";
+ TokenID.BarBar = 76;
+ TokenID._map[77] = "AmpersandAmpersand";
+ TokenID.AmpersandAmpersand = 77;
+ TokenID._map[78] = "Bar";
+ TokenID.Bar = 78;
+ TokenID._map[79] = "Caret";
+ TokenID.Caret = 79;
+ TokenID._map[80] = "And";
+ TokenID.And = 80;
+ TokenID._map[81] = "EqualsEquals";
+ TokenID.EqualsEquals = 81;
+ TokenID._map[82] = "ExclamationEquals";
+ TokenID.ExclamationEquals = 82;
+ TokenID._map[83] = "EqualsEqualsEquals";
+ TokenID.EqualsEqualsEquals = 83;
+ TokenID._map[84] = "ExclamationEqualsEquals";
+ TokenID.ExclamationEqualsEquals = 84;
+ TokenID._map[85] = "LessThan";
+ TokenID.LessThan = 85;
+ TokenID._map[86] = "LessThanEquals";
+ TokenID.LessThanEquals = 86;
+ TokenID._map[87] = "GreaterThan";
+ TokenID.GreaterThan = 87;
+ TokenID._map[88] = "GreaterThanEquals";
+ TokenID.GreaterThanEquals = 88;
+ TokenID._map[89] = "LessThanLessThan";
+ TokenID.LessThanLessThan = 89;
+ TokenID._map[90] = "GreaterThanGreaterThan";
+ TokenID.GreaterThanGreaterThan = 90;
+ TokenID._map[91] = "GreaterThanGreaterThanGreaterThan";
+ TokenID.GreaterThanGreaterThanGreaterThan = 91;
+ TokenID._map[92] = "Plus";
+ TokenID.Plus = 92;
+ TokenID._map[93] = "Minus";
+ TokenID.Minus = 93;
+ TokenID._map[94] = "Asterisk";
+ TokenID.Asterisk = 94;
+ TokenID._map[95] = "Slash";
+ TokenID.Slash = 95;
+ TokenID._map[96] = "Percent";
+ TokenID.Percent = 96;
+ TokenID._map[97] = "Tilde";
+ TokenID.Tilde = 97;
+ TokenID._map[98] = "Exclamation";
+ TokenID.Exclamation = 98;
+ TokenID._map[99] = "PlusPlus";
+ TokenID.PlusPlus = 99;
+ TokenID._map[100] = "MinusMinus";
+ TokenID.MinusMinus = 100;
+ TokenID._map[101] = "Dot";
+ TokenID.Dot = 101;
+ TokenID._map[102] = "DotDotDot";
+ TokenID.DotDotDot = 102;
+ TokenID._map[103] = "Error";
+ TokenID.Error = 103;
+ TokenID._map[104] = "EndOfFile";
+ TokenID.EndOfFile = 104;
+ TokenID._map[105] = "EqualsGreaterThan";
+ TokenID.EqualsGreaterThan = 105;
+ TokenID._map[106] = "Identifier";
+ TokenID.Identifier = 106;
+ TokenID._map[107] = "StringLiteral";
+ TokenID.StringLiteral = 107;
+ TokenID._map[108] = "RegularExpressionLiteral";
+ TokenID.RegularExpressionLiteral = 108;
+ TokenID._map[109] = "NumberLiteral";
+ TokenID.NumberLiteral = 109;
+ TokenID._map[110] = "Whitespace";
+ TokenID.Whitespace = 110;
+ TokenID._map[111] = "Comment";
+ TokenID.Comment = 111;
+ TokenID._map[112] = "Lim";
+ TokenID.Lim = 112;
+ TokenID.LimFixed = TokenID.EqualsGreaterThan;
+ TokenID.LimKeyword = TokenID.Yield;
+ })(TypeScript.TokenID || (TypeScript.TokenID = {}));
+ var TokenID = TypeScript.TokenID;
+ TypeScript.tokenTable = new Array();
+ TypeScript.nodeTypeTable = new Array();
+ TypeScript.nodeTypeToTokTable = new Array();
+ TypeScript.noRegexTable = new Array();
+ TypeScript.noRegexTable[TokenID.Identifier] = true;
+ TypeScript.noRegexTable[TokenID.StringLiteral] = true;
+ TypeScript.noRegexTable[TokenID.NumberLiteral] = true;
+ TypeScript.noRegexTable[TokenID.RegularExpressionLiteral] = true;
+ TypeScript.noRegexTable[TokenID.This] = true;
+ TypeScript.noRegexTable[TokenID.PlusPlus] = true;
+ TypeScript.noRegexTable[TokenID.MinusMinus] = true;
+ TypeScript.noRegexTable[TokenID.CloseParen] = true;
+ TypeScript.noRegexTable[TokenID.CloseBracket] = true;
+ TypeScript.noRegexTable[TokenID.CloseBrace] = true;
+ TypeScript.noRegexTable[TokenID.True] = true;
+ TypeScript.noRegexTable[TokenID.False] = true;
+ (function (OperatorPrecedence) {
+ OperatorPrecedence._map = [];
+ OperatorPrecedence._map[0] = "None";
+ OperatorPrecedence.None = 0;
+ OperatorPrecedence._map[1] = "Comma";
+ OperatorPrecedence.Comma = 1;
+ OperatorPrecedence._map[2] = "Assignment";
+ OperatorPrecedence.Assignment = 2;
+ OperatorPrecedence._map[3] = "Conditional";
+ OperatorPrecedence.Conditional = 3;
+ OperatorPrecedence._map[4] = "LogicalOr";
+ OperatorPrecedence.LogicalOr = 4;
+ OperatorPrecedence._map[5] = "LogicalAnd";
+ OperatorPrecedence.LogicalAnd = 5;
+ OperatorPrecedence._map[6] = "BitwiseOr";
+ OperatorPrecedence.BitwiseOr = 6;
+ OperatorPrecedence._map[7] = "BitwiseExclusiveOr";
+ OperatorPrecedence.BitwiseExclusiveOr = 7;
+ OperatorPrecedence._map[8] = "BitwiseAnd";
+ OperatorPrecedence.BitwiseAnd = 8;
+ OperatorPrecedence._map[9] = "Equality";
+ OperatorPrecedence.Equality = 9;
+ OperatorPrecedence._map[10] = "Relational";
+ OperatorPrecedence.Relational = 10;
+ OperatorPrecedence._map[11] = "Shift";
+ OperatorPrecedence.Shift = 11;
+ OperatorPrecedence._map[12] = "Additive";
+ OperatorPrecedence.Additive = 12;
+ OperatorPrecedence._map[13] = "Multiplicative";
+ OperatorPrecedence.Multiplicative = 13;
+ OperatorPrecedence._map[14] = "Unary";
+ OperatorPrecedence.Unary = 14;
+ OperatorPrecedence._map[15] = "Lim";
+ OperatorPrecedence.Lim = 15;
+ })(TypeScript.OperatorPrecedence || (TypeScript.OperatorPrecedence = {}));
+ var OperatorPrecedence = TypeScript.OperatorPrecedence;
+ (function (Reservation) {
+ Reservation._map = [];
+ Reservation.None = 0;
+ Reservation.Javascript = 1;
+ Reservation.JavascriptFuture = 2;
+ Reservation.TypeScript = 4;
+ Reservation.JavascriptFutureStrict = 8;
+ Reservation.TypeScriptAndJS = Reservation.Javascript | Reservation.TypeScript;
+ Reservation.TypeScriptAndJSFuture = Reservation.JavascriptFuture | Reservation.TypeScript;
+ Reservation.TypeScriptAndJSFutureStrict = Reservation.JavascriptFutureStrict | Reservation.TypeScript;
+ })(TypeScript.Reservation || (TypeScript.Reservation = {}));
+ var Reservation = TypeScript.Reservation;
+ var TokenInfo = (function () {
+ function TokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers) {
+ this.tokenId = tokenId;
+ this.reservation = reservation;
+ this.binopPrecedence = binopPrecedence;
+ this.binopNodeType = binopNodeType;
+ this.unopPrecedence = unopPrecedence;
+ this.unopNodeType = unopNodeType;
+ this.text = text;
+ this.ers = ers;
+ }
+ return TokenInfo;
+ })();
+ TypeScript.TokenInfo = TokenInfo;
+ function setTokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers) {
+ if(tokenId !== undefined) {
+ TypeScript.tokenTable[tokenId] = new TokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers);
+ if(binopNodeType != TypeScript.NodeType.None) {
+ TypeScript.nodeTypeTable[binopNodeType] = text;
+ TypeScript.nodeTypeToTokTable[binopNodeType] = tokenId;
+ }
+ if(unopNodeType != TypeScript.NodeType.None) {
+ TypeScript.nodeTypeTable[unopNodeType] = text;
+ }
+ }
+ }
+ setTokenInfo(TokenID.Any, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "any", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Bool, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "bool", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Break, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "break", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Case, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "case", TypeScript.ErrorRecoverySet.SCase);
+ setTokenInfo(TokenID.Catch, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "catch", TypeScript.ErrorRecoverySet.Catch);
+ setTokenInfo(TokenID.Class, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "class", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Const, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "const", TypeScript.ErrorRecoverySet.Var);
+ setTokenInfo(TokenID.Continue, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "continue", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Debugger, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.Debugger, "debugger", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Default, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "default", TypeScript.ErrorRecoverySet.SCase);
+ setTokenInfo(TokenID.Delete, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Delete, "delete", TypeScript.ErrorRecoverySet.Prefix);
+ setTokenInfo(TokenID.Do, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "do", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Else, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "else", TypeScript.ErrorRecoverySet.Else);
+ setTokenInfo(TokenID.Enum, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "enum", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Export, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "export", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Extends, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "extends", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Declare, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "declare", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.False, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "false", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Finally, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "finally", TypeScript.ErrorRecoverySet.Catch);
+ setTokenInfo(TokenID.For, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "for", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Function, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "function", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.Constructor, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "constructor", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.Get, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "get", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.Set, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "set", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.If, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "if", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Implements, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "implements", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Import, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "import", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.In, Reservation.TypeScriptAndJS, OperatorPrecedence.Relational, TypeScript.NodeType.In, OperatorPrecedence.None, TypeScript.NodeType.None, "in", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.InstanceOf, Reservation.TypeScriptAndJS, OperatorPrecedence.Relational, TypeScript.NodeType.InstOf, OperatorPrecedence.None, TypeScript.NodeType.None, "instanceof", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Interface, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "interface", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Let, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "let", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Module, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "module", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.New, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "new", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.Number, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "number", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Null, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "null", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Package, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "package", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Private, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "private", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Protected, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "protected", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Public, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "public", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Return, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "return", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Static, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "static", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.String, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "string", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Super, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "super", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Switch, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "switch", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.This, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "this", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Throw, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "throw", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.True, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "true", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Try, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "try", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.TypeOf, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Typeof, "typeof", TypeScript.ErrorRecoverySet.Prefix);
+ setTokenInfo(TokenID.Var, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "var", TypeScript.ErrorRecoverySet.Var);
+ setTokenInfo(TokenID.Void, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Void, "void", TypeScript.ErrorRecoverySet.Prefix);
+ setTokenInfo(TokenID.With, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.With, "with", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.While, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "while", TypeScript.ErrorRecoverySet.While);
+ setTokenInfo(TokenID.Yield, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "yield", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Identifier, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "identifier", TypeScript.ErrorRecoverySet.ID);
+ setTokenInfo(TokenID.NumberLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "numberLiteral", TypeScript.ErrorRecoverySet.Literal);
+ setTokenInfo(TokenID.RegularExpressionLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "regex", TypeScript.ErrorRecoverySet.RegExp);
+ setTokenInfo(TokenID.StringLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "qstring", TypeScript.ErrorRecoverySet.Literal);
+ setTokenInfo(TokenID.Semicolon, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ";", TypeScript.ErrorRecoverySet.SColon);
+ setTokenInfo(TokenID.CloseParen, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ")", TypeScript.ErrorRecoverySet.RParen);
+ setTokenInfo(TokenID.CloseBracket, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "]", TypeScript.ErrorRecoverySet.RBrack);
+ setTokenInfo(TokenID.OpenBrace, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "{", TypeScript.ErrorRecoverySet.LCurly);
+ setTokenInfo(TokenID.CloseBrace, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "}", TypeScript.ErrorRecoverySet.RCurly);
+ setTokenInfo(TokenID.DotDotDot, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "...", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Comma, Reservation.None, OperatorPrecedence.Comma, TypeScript.NodeType.Comma, OperatorPrecedence.None, TypeScript.NodeType.None, ",", TypeScript.ErrorRecoverySet.Comma);
+ setTokenInfo(TokenID.Equals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.Asg, OperatorPrecedence.None, TypeScript.NodeType.None, "=", TypeScript.ErrorRecoverySet.Asg);
+ setTokenInfo(TokenID.PlusEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgAdd, OperatorPrecedence.None, TypeScript.NodeType.None, "+=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.MinusEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgSub, OperatorPrecedence.None, TypeScript.NodeType.None, "-=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.AsteriskEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgMul, OperatorPrecedence.None, TypeScript.NodeType.None, "*=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.SlashEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgDiv, OperatorPrecedence.None, TypeScript.NodeType.None, "/=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.PercentEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgMod, OperatorPrecedence.None, TypeScript.NodeType.None, "%=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.AmpersandEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgAnd, OperatorPrecedence.None, TypeScript.NodeType.None, "&=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.CaretEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgXor, OperatorPrecedence.None, TypeScript.NodeType.None, "^=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.BarEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgOr, OperatorPrecedence.None, TypeScript.NodeType.None, "|=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThanLessThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgLsh, OperatorPrecedence.None, TypeScript.NodeType.None, "<<=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgRsh, OperatorPrecedence.None, TypeScript.NodeType.None, ">>=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThanGreaterThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgRs2, OperatorPrecedence.None, TypeScript.NodeType.None, ">>>=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Question, Reservation.None, OperatorPrecedence.Conditional, TypeScript.NodeType.ConditionalExpression, OperatorPrecedence.None, TypeScript.NodeType.None, "?", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Colon, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ":", TypeScript.ErrorRecoverySet.Colon);
+ setTokenInfo(TokenID.BarBar, Reservation.None, OperatorPrecedence.LogicalOr, TypeScript.NodeType.LogOr, OperatorPrecedence.None, TypeScript.NodeType.None, "||", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.AmpersandAmpersand, Reservation.None, OperatorPrecedence.LogicalAnd, TypeScript.NodeType.LogAnd, OperatorPrecedence.None, TypeScript.NodeType.None, "&&", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Bar, Reservation.None, OperatorPrecedence.BitwiseOr, TypeScript.NodeType.Or, OperatorPrecedence.None, TypeScript.NodeType.None, "|", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Caret, Reservation.None, OperatorPrecedence.BitwiseExclusiveOr, TypeScript.NodeType.Xor, OperatorPrecedence.None, TypeScript.NodeType.None, "^", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.And, Reservation.None, OperatorPrecedence.BitwiseAnd, TypeScript.NodeType.And, OperatorPrecedence.None, TypeScript.NodeType.None, "&", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.EqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Eq, OperatorPrecedence.None, TypeScript.NodeType.None, "==", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.ExclamationEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Ne, OperatorPrecedence.None, TypeScript.NodeType.None, "!=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.EqualsEqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Eqv, OperatorPrecedence.None, TypeScript.NodeType.None, "===", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.ExclamationEqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.NEqv, OperatorPrecedence.None, TypeScript.NodeType.None, "!==", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThan, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Lt, OperatorPrecedence.None, TypeScript.NodeType.None, "<", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThanEquals, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Le, OperatorPrecedence.None, TypeScript.NodeType.None, "<=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThan, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Gt, OperatorPrecedence.None, TypeScript.NodeType.None, ">", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanEquals, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Ge, OperatorPrecedence.None, TypeScript.NodeType.None, ">=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThanLessThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Lsh, OperatorPrecedence.None, TypeScript.NodeType.None, "<<", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Rsh, OperatorPrecedence.None, TypeScript.NodeType.None, ">>", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThanGreaterThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Rs2, OperatorPrecedence.None, TypeScript.NodeType.None, ">>>", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Plus, Reservation.None, OperatorPrecedence.Additive, TypeScript.NodeType.Add, OperatorPrecedence.Unary, TypeScript.NodeType.Pos, "+", TypeScript.ErrorRecoverySet.AddOp);
+ setTokenInfo(TokenID.Minus, Reservation.None, OperatorPrecedence.Additive, TypeScript.NodeType.Sub, OperatorPrecedence.Unary, TypeScript.NodeType.Neg, "-", TypeScript.ErrorRecoverySet.AddOp);
+ setTokenInfo(TokenID.Asterisk, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Mul, OperatorPrecedence.None, TypeScript.NodeType.None, "*", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Slash, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Div, OperatorPrecedence.None, TypeScript.NodeType.None, "/", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Percent, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Mod, OperatorPrecedence.None, TypeScript.NodeType.None, "%", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Tilde, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Not, "~", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.Exclamation, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.LogNot, "!", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.PlusPlus, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.IncPre, "++", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.MinusMinus, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.DecPre, "--", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.OpenParen, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "(", TypeScript.ErrorRecoverySet.LParen);
+ setTokenInfo(TokenID.OpenBracket, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "[", TypeScript.ErrorRecoverySet.LBrack);
+ setTokenInfo(TokenID.Dot, Reservation.None, OperatorPrecedence.Unary, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ".", TypeScript.ErrorRecoverySet.Dot);
+ setTokenInfo(TokenID.EndOfFile, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "", TypeScript.ErrorRecoverySet.EOF);
+ setTokenInfo(TokenID.EqualsGreaterThan, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "=>", TypeScript.ErrorRecoverySet.None);
+ function lookupToken(tokenId) {
+ return TypeScript.tokenTable[tokenId];
+ }
+ TypeScript.lookupToken = lookupToken;
+ (function (TokenClass) {
+ TokenClass._map = [];
+ TokenClass._map[0] = "Punctuation";
+ TokenClass.Punctuation = 0;
+ TokenClass._map[1] = "Keyword";
+ TokenClass.Keyword = 1;
+ TokenClass._map[2] = "Operator";
+ TokenClass.Operator = 2;
+ TokenClass._map[3] = "Comment";
+ TokenClass.Comment = 3;
+ TokenClass._map[4] = "Whitespace";
+ TokenClass.Whitespace = 4;
+ TokenClass._map[5] = "Identifier";
+ TokenClass.Identifier = 5;
+ TokenClass._map[6] = "NumberLiteral";
+ TokenClass.NumberLiteral = 6;
+ TokenClass._map[7] = "StringLiteral";
+ TokenClass.StringLiteral = 7;
+ TokenClass._map[8] = "RegExpLiteral";
+ TokenClass.RegExpLiteral = 8;
+ })(TypeScript.TokenClass || (TypeScript.TokenClass = {}));
+ var TokenClass = TypeScript.TokenClass;
+ var SavedToken = (function () {
+ function SavedToken(tok, minChar, limChar) {
+ this.tok = tok;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ }
+ return SavedToken;
+ })();
+ TypeScript.SavedToken = SavedToken;
+ var Token = (function () {
+ function Token(tokenId) {
+ this.tokenId = tokenId;
+ }
+ Token.prototype.toString = function () {
+ return "token: " + this.tokenId + " " + this.getText() + " (" + (TokenID)._map[this.tokenId] + ")";
+ };
+ Token.prototype.print = function (line, outfile) {
+ outfile.WriteLine(this.toString() + ",on line" + line);
+ };
+ Token.prototype.getText = function () {
+ return TypeScript.tokenTable[this.tokenId].text;
+ };
+ Token.prototype.classification = function () {
+ if(this.tokenId <= TokenID.LimKeyword) {
+ return TokenClass.Keyword;
+ } else {
+ var tokenInfo = lookupToken(this.tokenId);
+ if(tokenInfo != undefined) {
+ if((tokenInfo.unopNodeType != TypeScript.NodeType.None) || (tokenInfo.binopNodeType != TypeScript.NodeType.None)) {
+ return TokenClass.Operator;
+ }
+ }
+ }
+ return TokenClass.Punctuation;
+ };
+ return Token;
+ })();
+ TypeScript.Token = Token;
+ var NumberLiteralToken = (function (_super) {
+ __extends(NumberLiteralToken, _super);
+ function NumberLiteralToken(value, text) {
+ _super.call(this, TokenID.NumberLiteral);
+ this.value = value;
+ this.text = text;
+ }
+ NumberLiteralToken.prototype.getText = function () {
+ return this.text;
+ };
+ 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(text) {
+ _super.call(this, TokenID.RegularExpressionLiteral);
+ this.text = text;
+ }
+ RegularExpressionLiteralToken.prototype.getText = function () {
+ return this.text;
+ };
+ 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.Signature);
+ 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 || !symbol.isType()) {
+ 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 && symbol.declAST && symbol.declAST.nodeType != TypeScript.NodeType.ModuleDeclaration) {
+ context.checker.errorReporter.simpleError(moduleDecl, "Conflicting symbol name for module '" + modName + "'");
+ symbol = null;
+ modName = "";
+ }
+ if(symbol) {
+ var modDeclAST = symbol.declAST;
+ var modDeclASTIsExported = TypeScript.hasFlag(modDeclAST.modFlags, TypeScript.ModuleFlags.Exported);
+ if((modDeclASTIsExported && !isExported) || (!modDeclASTIsExported && isExported)) {
+ context.checker.errorReporter.simpleError(moduleDecl, 'All contributions to a module must be "export" or none');
+ }
+ }
+ 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 {
+ 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;
+ }
+ if(fgSym && !fgSym.isAccessor() && funcDecl.isAccessor()) {
+ fgSym = null;
+ }
+ 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;
+ var svCurrentModDecl = this.checker.currentModDecl;
+ 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;
+ }
+ if(type.isModuleType()) {
+ this.checker.currentModDecl = container.declAST;
+ break;
+ }
+ }
+ container = container.container;
+ }
+ this.typeCheckBoundDecl(varDecl);
+ this.checker.currentModDecl = svCurrentModDecl;
+ 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) {
+ 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)) {
+ if(infSym.typeCheckStatus == TypeScript.TypeCheckStatus.Started) {
+ infSym.declAST.type = this.anyType;
+ infSym.setType(this.anyType);
+ } else {
+ 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]);
+ }
+ 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 (constructorDecl, table, isClass) {
+ var container = constructorDecl.type.symbol;
+ var args = constructorDecl.arguments;
+ 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.funcDecl = constructorDecl;
+ 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;
+ }
+ if(funcDecl.classDecl.type.construct == null) {
+ this.checker.errorReporter.simpleError(funcDecl, "Malformed constructor (is this a class named the same as an existing class?)");
+ 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;
+ 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, 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, 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);
+ }
+ var apparentTarget = target.nodeType == TypeScript.NodeType.Dot ? (target).operand2 : target;
+ 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(apparentTarget, "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(apparentTarget, emsg + ":\n\t" + comparisonInfo.message);
+ } else {
+ this.checker.errorReporter.simpleError(apparentTarget, 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(apparentTarget, "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, getPrettyTypeName) {
+ return this.getMemberTypeName("", true, false, scope, getPrettyTypeName);
+ };
+ Type.prototype.getScopedTypeNameEx = function (scope, getPrettyTypeName) {
+ return this.getMemberTypeNameEx("", true, false, scope, getPrettyTypeName);
+ };
+ 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, getPrettyTypeName) {
+ var memberName = this.getMemberTypeNameEx(prefix, topLevel, isElementType, scope, getPrettyTypeName);
+ return memberName.toString();
+ };
+ Type.prototype.getMemberTypeNameEx = function (prefix, topLevel, isElementType, scope, getPrettyTypeName) {
+ 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 getPrettyFunctionOverload = getPrettyTypeName && !curlies && this.call && this.call.signatures.length > 1 && !this.members && !this.construct;
+ var shortform = !curlies && (signatureCount == 1 || getPrettyFunctionOverload) && topLevel;
+ if(this.call) {
+ allMemberNames.addAll(this.call.toStrings(prefix, shortform, scope, getPrettyFunctionOverload));
+ }
+ if(this.construct) {
+ allMemberNames.addAll(this.construct.toStrings("new", shortform, scope));
+ }
+ if(this.index) {
+ allMemberNames.addAll(this.index.toStrings("", shortform, scope));
+ }
+ if((curlies) || (!getPrettyFunctionOverload && (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 isSingleQuoted(str) {
+ return str.indexOf("'") != -1;
+ }
+ TypeScript.isSingleQuoted = isSingleQuoted;
+ function isQuoted(str) {
+ return str.indexOf("\"") != -1 || isSingleQuoted(str);
+ }
+ 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 changeToSingleQuote(str) {
+ if(str.indexOf("\"") != -1) {
+ str = str.replace("\"", "'");
+ str = str.replace("\"", "'");
+ }
+ return str;
+ }
+ TypeScript.changeToSingleQuote = changeToSingleQuote;
+ 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 = [];
+ this.inputOutputMap = [];
+ }
+ 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: null,
+ 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);
+ return false;
+ }
+ } 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 != null) {
+ var rootDir = ioHost.dirName(resolvedFile.path);
+ var sourceUnit = new SourceUnit(resolvedFile.path, resolvedFile.content);
+ var preProcessedFileInfo = TypeScript.preProcessFile(sourceUnit, this.environment.compilationSettings);
+ var resolvedFilePath = ioHost.resolvePath(resolvedFile.path);
+ sourceUnit.referencedFiles = preProcessedFileInfo.referencedFiles;
+ for(var i = 0; i < preProcessedFileInfo.referencedFiles.length; i++) {
+ var fileReference = preProcessedFileInfo.referencedFiles[i];
+ var normalizedPath = TypeScript.isRooted(fileReference.path) ? fileReference.path : rootDir + "/" + fileReference.path;
+ normalizedPath = ioHost.resolvePath(normalizedPath);
+ if(resolvedFilePath == normalizedPath) {
+ resolutionDispatcher.postResolutionError(normalizedPath, fileReference.startLine, fileReference.startCol, "Incorrect reference: File contains reference to itself.");
+ continue;
+ }
+ var resolutionResult = this.resolveCode(fileReference.path, rootDir, false, resolutionDispatcher);
+ if(!resolutionResult) {
+ resolutionDispatcher.postResolutionError(resolvedFilePath, fileReference.startLine, fileReference.startCol, "Incorrect reference: referenced file: \"" + fileReference.path + "\" cannot be resolved.");
+ }
+ }
+ for(var i = 0; i < preProcessedFileInfo.importedFiles.length; i++) {
+ var fileImport = preProcessedFileInfo.importedFiles[i];
+ var resolutionResult = this.resolveCode(fileImport.path, rootDir, true, resolutionDispatcher);
+ if(!resolutionResult) {
+ resolutionDispatcher.postResolutionError(resolvedFilePath, fileImport.startLine, fileImport.startCol, "Incorrect reference: imported file: \"" + fileImport.path + "\" cannot be resolved.");
+ }
+ }
+ resolutionDispatcher.postResolution(sourceUnit.path, sourceUnit);
+ }
+ }
+ return true;
+ };
+ 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.emitFullSourceMapPath = 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*/gim;
+ 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,
+ startLine: 0,
+ startCol: 0,
+ path: TypeScript.switchToForwardSlashes(adjustedPath),
+ isResident: isResident
+ };
+ } else {
+ return null;
+ }
+ }
+ function getAdditionalDependencyPath(comment) {
+ var amdDependencyRegEx = /^(\/\/\/\s*/gim;
+ 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*/gim;
+ var match = implicitImportRegEx.exec(comment);
+ if(match) {
+ return true;
+ }
+ return false;
+ }
+ TypeScript.getImplicitImport = getImplicitImport;
+ function getStyleSettings(comment, styleSettings) {
+ var styleRegEx = /^(\/\/\/\s*/gim;
+ var settings = styleRegEx.exec(comment);
+ if(settings) {
+ var settingsRegEx = /^([a-zA-Z]+=['"]on['|"])/gim;
+ 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,
+ startLine: scanner.line,
+ startCol: scanner.col,
+ 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;
+ var result = {
+ line: -1,
+ col: -1
+ };
+ TypeScript.getSourceLineColFromMap(result, comment.startPos, scanner.lineMap);
+ if(result.col >= 0) {
+ result.col++;
+ }
+ referencedCode.startLine = result.line;
+ referencedCode.startCol = result.col;
+ referencedFiles.push(referencedCode);
+ }
+ if(settings) {
+ getStyleSettings(comment.getText(), settings.styleSettings);
+ var isNoLibRegex = /^(\/\/\/\s*/gim;
+ 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)) {
+ if(TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.Private)) {
+ result += "private ";
+ }
+ 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");
+ if(id != "__missing" || !funcDecl.name || !funcDecl.name.isMissing()) {
+ this.declFile.Write(id);
+ } else if(funcDecl.isConstructMember()) {
+ this.declFile.Write("new");
+ }
+ } else {
+ this.emitIndent();
+ if(funcDecl.isConstructMember()) {
+ this.declFile.Write("new");
+ } else if(!funcDecl.isCallMember() && !funcDecl.isIndexerMember()) {
+ this.declFile.Write(id);
+ if(TypeScript.hasFlag(funcDecl.name.flags, TypeScript.ASTFlags.OptionalName)) {
+ this.declFile.Write("? ");
+ }
+ }
+ }
+ }
+ if(!funcDecl.isIndexerMember()) {
+ this.declFile.Write("(");
+ } else {
+ this.declFile.Write("[");
+ }
+ this.indenter.increaseIndent();
+ if(funcDecl.arguments) {
+ var argsLen = funcDecl.arguments.members.length;
+ if(funcDecl.variableArgList) {
+ argsLen--;
+ }
+ for(var i = 0; i < argsLen; i++) {
+ var argDecl = funcDecl.arguments.members[i];
+ this.emitArgDecl(argDecl, funcDecl);
+ if(i < (argsLen - 1)) {
+ this.declFile.Write(", ");
+ }
+ }
+ }
+ if(funcDecl.variableArgList) {
+ var lastArg = funcDecl.arguments.members[funcDecl.arguments.members.length - 1];
+ if(funcDecl.arguments.members.length > 1) {
+ this.declFile.Write(", ...");
+ } else {
+ this.declFile.Write("...");
+ }
+ this.emitArgDecl(lastArg, funcDecl);
+ }
+ this.indenter.decreaseIndent();
+ if(!funcDecl.isIndexerMember()) {
+ this.declFile.Write(")");
+ } else {
+ this.declFile.Write("]");
+ }
+ if(!funcDecl.isConstructor && (funcDecl.returnTypeAnnotation || funcDecl.signature.returnType.type != this.checker.anyType) && this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(funcDecl.fncFlags))) {
+ this.declFile.Write(": ");
+ this.emitTypeSignature(funcDecl.signature.returnType.type);
+ }
+ this.declFile.WriteLine(";");
+ return false;
+ };
+ DeclarationEmitter.prototype.emitBaseList = function (bases, qual) {
+ if(bases && (bases.members.length > 0)) {
+ this.declFile.Write(" " + qual + " ");
+ var basesLen = bases.members.length;
+ for(var i = 0; i < basesLen; i++) {
+ var baseExpr = bases.members[i];
+ var baseSymbol = baseExpr.type.symbol;
+ var baseType = baseExpr.type;
+ if(i > 0) {
+ this.declFile.Write(", ");
+ }
+ this.emitTypeSignature(baseType);
+ }
+ }
+ };
+ DeclarationEmitter.prototype.emitPropertyAccessorSignature = function (funcDecl) {
+ var accessorSymbol = funcDecl.accessorSymbol;
+ if(accessorSymbol.getter && accessorSymbol.getter.declAST != funcDecl) {
+ return false;
+ }
+ this.emitDeclarationComments(accessorSymbol);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(accessorSymbol.flags), "var");
+ this.declFile.Write(funcDecl.name.text);
+ var propertyType = accessorSymbol.getType();
+ if(this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(accessorSymbol.flags))) {
+ this.declFile.Write(" : ");
+ this.emitTypeSignature(propertyType);
+ }
+ this.declFile.WriteLine(";");
+ return false;
+ };
+ DeclarationEmitter.prototype.emitClassMembersFromConstructorDefinition = function (funcDecl) {
+ if(funcDecl.arguments) {
+ var argsLen = funcDecl.arguments.members.length;
+ if(funcDecl.variableArgList) {
+ argsLen--;
+ }
+ for(var i = 0; i < argsLen; i++) {
+ var argDecl = funcDecl.arguments.members[i];
+ if(TypeScript.hasFlag(argDecl.varFlags, TypeScript.VarFlags.Property)) {
+ this.emitDeclarationComments(argDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(argDecl.varFlags), "var");
+ this.declFile.Write(argDecl.id.text);
+ if(argDecl.typeExpr && this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(argDecl.varFlags))) {
+ this.declFile.Write(": ");
+ this.emitTypeSignature(argDecl.type);
+ }
+ this.declFile.WriteLine(";");
+ }
+ }
+ }
+ };
+ DeclarationEmitter.prototype.ClassDeclarationCallback = function (pre, classDecl) {
+ if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(classDecl.varFlags), classDecl, pre)) {
+ return false;
+ }
+ if(pre) {
+ var className = classDecl.name.text;
+ this.emitDeclarationComments(classDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(classDecl.varFlags), "class");
+ this.declFile.Write(className);
+ this.emitBaseList(classDecl.extendsList, "extends");
+ this.emitBaseList(classDecl.implementsList, "implements");
+ this.declFile.WriteLine(" {");
+ this.pushDeclarationContainer(classDecl);
+ this.indenter.increaseIndent();
+ if(classDecl.constructorDecl) {
+ this.emitClassMembersFromConstructorDefinition(classDecl.constructorDecl);
+ }
+ } else {
+ this.indenter.decreaseIndent();
+ this.popDeclarationContainer(classDecl);
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.InterfaceDeclarationCallback = function (pre, interfaceDecl) {
+ if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(interfaceDecl.varFlags), interfaceDecl, pre)) {
+ return false;
+ }
+ if(pre) {
+ var interfaceName = interfaceDecl.name.text;
+ this.emitDeclarationComments(interfaceDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(interfaceDecl.varFlags), "interface");
+ this.declFile.Write(interfaceName);
+ this.emitBaseList(interfaceDecl.extendsList, "extends");
+ this.declFile.WriteLine(" {");
+ this.indenter.increaseIndent();
+ this.pushDeclarationContainer(interfaceDecl);
+ } else {
+ this.indenter.decreaseIndent();
+ this.popDeclarationContainer(interfaceDecl);
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.ImportDeclarationCallback = function (pre, importDecl) {
+ if(pre) {
+ if((this.declarationContainerStack[0]).isExternallyVisibleSymbol(importDecl.id.sym)) {
+ this.emitDeclarationComments(importDecl);
+ this.emitIndent();
+ this.declFile.Write("import ");
+ this.declFile.Write(importDecl.id.text + " = ");
+ if(importDecl.isDynamicImport) {
+ this.declFile.WriteLine("module (" + importDecl.getAliasName() + ");");
+ } else {
+ this.declFile.WriteLine(importDecl.getAliasName() + ";");
+ }
+ }
+ }
+ return false;
+ };
+ DeclarationEmitter.prototype.emitEnumSignature = function (moduleDecl) {
+ if(!this.canEmitSignature(TypeScript.ToDeclFlags(moduleDecl.modFlags))) {
+ return false;
+ }
+ this.emitDeclarationComments(moduleDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(moduleDecl.modFlags), "enum");
+ this.declFile.WriteLine(moduleDecl.name.text + " {");
+ this.indenter.increaseIndent();
+ var membersLen = moduleDecl.members.members.length;
+ for(var j = 1; j < membersLen; j++) {
+ var memberDecl = moduleDecl.members.members[j];
+ if(memberDecl.nodeType == TypeScript.NodeType.VarDecl) {
+ this.emitDeclarationComments(memberDecl);
+ this.emitIndent();
+ this.declFile.WriteLine((memberDecl).id.text + ",");
+ } else {
+ TypeScript.CompilerDiagnostics.assert(memberDecl.nodeType != TypeScript.NodeType.Asg, "We want to catch this");
+ }
+ }
+ this.indenter.decreaseIndent();
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ return false;
+ };
+ DeclarationEmitter.prototype.ModuleDeclarationCallback = function (pre, moduleDecl) {
+ if(TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsWholeFile)) {
+ if(TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsDynamic)) {
+ if(pre) {
+ if(!this.emitOptions.outputMany) {
+ this.singleDeclFile = this.declFile;
+ TypeScript.CompilerDiagnostics.assert(this.indenter.indentAmt == 0, "Indent has to be 0 when outputing new file");
+ var declareFileName = this.emitOptions.mapOutputFileName(TypeScript.stripQuotes(moduleDecl.name.sym.name), TypeScript.TypeScriptCompiler.mapToDTSFileName);
+ var useUTF8InOutputfile = moduleDecl.containsUnicodeChar || (this.emitOptions.emitComments && moduleDecl.containsUnicodeCharInComment);
+ try {
+ this.declFile = new DeclFileWriter(this.emitOptions.ioHost.createFile(declareFileName, useUTF8InOutputfile));
+ } catch (ex) {
+ this.errorReporter.emitterError(null, ex.message);
+ }
+ }
+ this.pushDeclarationContainer(moduleDecl);
+ } else {
+ if(!this.emitOptions.outputMany) {
+ TypeScript.CompilerDiagnostics.assert(this.singleDeclFile != this.declFile, "singleDeclFile cannot be null as we are going to revert back to it");
+ TypeScript.CompilerDiagnostics.assert(this.indenter.indentAmt == 0, "Indent has to be 0 when outputing new file");
+ try {
+ this.declFile.Close();
+ } catch (ex) {
+ this.errorReporter.emitterError(null, ex.message);
+ }
+ this.declFile = this.singleDeclFile;
+ }
+ this.popDeclarationContainer(moduleDecl);
+ }
+ }
+ return true;
+ }
+ if(moduleDecl.isEnum()) {
+ if(pre) {
+ this.emitEnumSignature(moduleDecl);
+ }
+ return false;
+ }
+ if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(moduleDecl.modFlags), moduleDecl, pre)) {
+ return false;
+ }
+ if(pre) {
+ if(this.emitDottedModuleName()) {
+ this.dottedModuleEmit += ".";
+ } else {
+ this.dottedModuleEmit = this.getDeclFlagsString(TypeScript.ToDeclFlags(moduleDecl.modFlags), "module");
+ }
+ this.dottedModuleEmit += moduleDecl.name.text;
+ var isCurrentModuleDotted = (moduleDecl.members.members.length == 1 && moduleDecl.members.members[0].nodeType == TypeScript.NodeType.ModuleDeclaration && !(moduleDecl.members.members[0]).isEnum() && TypeScript.hasFlag((moduleDecl.members.members[0]).modFlags, TypeScript.ModuleFlags.Exported));
+ var moduleDeclComments = moduleDecl.getDocComments();
+ isCurrentModuleDotted = isCurrentModuleDotted && (moduleDeclComments == null || moduleDeclComments.length == 0);
+ this.isDottedModuleName.push(isCurrentModuleDotted);
+ this.pushDeclarationContainer(moduleDecl);
+ if(!isCurrentModuleDotted) {
+ this.emitDeclarationComments(moduleDecl);
+ this.declFile.Write(this.dottedModuleEmit);
+ this.declFile.WriteLine(" {");
+ this.indenter.increaseIndent();
+ }
+ } else {
+ if(!this.emitDottedModuleName()) {
+ this.indenter.decreaseIndent();
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ }
+ this.popDeclarationContainer(moduleDecl);
+ this.isDottedModuleName.pop();
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.ScriptCallback = function (pre, script) {
+ if(pre) {
+ if(this.emitOptions.outputMany) {
+ for(var i = 0; i < script.referencedFiles.length; i++) {
+ var referencePath = script.referencedFiles[i].path;
+ var declareFileName;
+ if(TypeScript.isRooted(referencePath)) {
+ declareFileName = this.emitOptions.mapOutputFileName(referencePath, TypeScript.TypeScriptCompiler.mapToDTSFileName);
+ } else {
+ declareFileName = TypeScript.getDeclareFilePath(script.referencedFiles[i].path);
+ }
+ this.declFile.WriteLine('/// ');
+ }
+ }
+ this.pushDeclarationContainer(script);
+ } else {
+ this.popDeclarationContainer(script);
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.DefaultCallback = function (pre, ast) {
+ return !TypeScript.hasFlag(ast.flags, TypeScript.ASTFlags.IsStatement);
+ };
+ return DeclarationEmitter;
+ })();
+ TypeScript.DeclarationEmitter = DeclarationEmitter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+ (function (UpdateUnitKind) {
+ UpdateUnitKind._map = [];
+ UpdateUnitKind._map[0] = "Unknown";
+ UpdateUnitKind.Unknown = 0;
+ UpdateUnitKind._map[1] = "NoEdits";
+ UpdateUnitKind.NoEdits = 1;
+ UpdateUnitKind._map[2] = "EditsInsideSingleScope";
+ UpdateUnitKind.EditsInsideSingleScope = 2;
+ })(TypeScript.UpdateUnitKind || (TypeScript.UpdateUnitKind = {}));
+ var UpdateUnitKind = TypeScript.UpdateUnitKind;
+ var ScriptEditRange = (function () {
+ function ScriptEditRange(minChar, limChar, delta) {
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.delta = delta;
+ }
+ ScriptEditRange.unknown = function unknown() {
+ return new ScriptEditRange(-1, -1, -1);
+ };
+ ScriptEditRange.prototype.isUnknown = function () {
+ return this.minChar === -1 && this.limChar === -1 && this.delta === -1;
+ };
+ ScriptEditRange.prototype.containsPosition = function (pos) {
+ return (this.minChar <= pos && pos < this.limChar) || (this.minChar <= pos && pos < this.limChar + this.delta);
+ };
+ ScriptEditRange.prototype.toString = function () {
+ return "editRange(minChar=" + this.minChar + ", limChar=" + this.limChar + ", delta=" + this.delta + ")";
+ };
+ return ScriptEditRange;
+ })();
+ TypeScript.ScriptEditRange = ScriptEditRange;
+ var UpdateUnitResult = (function () {
+ function UpdateUnitResult(kind, unitIndex, script1, script2) {
+ this.kind = kind;
+ this.unitIndex = unitIndex;
+ this.script1 = script1;
+ this.script2 = script2;
+ this.scope1 = null;
+ this.scope2 = null;
+ this.editRange = null;
+ this.parseErrors = [];
+ }
+ UpdateUnitResult.noEdits = function noEdits(unitIndex) {
+ return new UpdateUnitResult(UpdateUnitKind.NoEdits, unitIndex, null, null);
+ };
+ UpdateUnitResult.unknownEdits = function unknownEdits(script1, script2, parseErrors) {
+ var result = new UpdateUnitResult(UpdateUnitKind.Unknown, script1.locationInfo.unitIndex, script1, script2);
+ result.parseErrors = parseErrors;
+ return result;
+ };
+ UpdateUnitResult.singleScopeEdits = function singleScopeEdits(script1, script2, scope1, scope2, editRange, parseErrors) {
+ var result = new UpdateUnitResult(UpdateUnitKind.EditsInsideSingleScope, script1.locationInfo.unitIndex, script1, script2);
+ result.scope1 = scope1;
+ result.scope2 = scope2;
+ result.editRange = editRange;
+ result.parseErrors = parseErrors;
+ return result;
+ };
+ return UpdateUnitResult;
+ })();
+ TypeScript.UpdateUnitResult = UpdateUnitResult;
+ var ErrorEntry = (function () {
+ function ErrorEntry(unitIndex, minChar, limChar, message) {
+ this.unitIndex = unitIndex;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.message = message;
+ }
+ return ErrorEntry;
+ })();
+ TypeScript.ErrorEntry = ErrorEntry;
+ TypeScript.defaultSettings = new TypeScript.CompilationSettings();
+ var TypeScriptCompiler = (function () {
+ function TypeScriptCompiler(errorOutput, logger, settings) {
+ if (typeof logger === "undefined") { logger = new TypeScript.NullLogger(); }
+ if (typeof settings === "undefined") { settings = TypeScript.defaultSettings; }
+ this.errorOutput = errorOutput;
+ this.logger = logger;
+ this.settings = settings;
+ this.parser = new TypeScript.Parser();
+ this.typeFlow = null;
+ this.scripts = new TypeScript.ASTList();
+ this.units = new Array();
+ this.errorReporter = new TypeScript.ErrorReporter(this.errorOutput);
+ this.persistentTypeState = new TypeScript.PersistentGlobalTypeState(this.errorReporter);
+ this.errorReporter.parser = this.parser;
+ this.initTypeChecker(this.errorOutput);
+ this.parser.style_requireSemi = this.settings.styleSettings.requireSemi;
+ this.parser.style_funcInLoop = this.settings.styleSettings.funcInLoop;
+ this.parser.inferPropertiesFromThisAssignment = this.settings.inferPropertiesFromThisAssignment;
+ this.emitSettings = new TypeScript.EmitOptions(this.settings);
+ TypeScript.codeGenTarget = settings.codeGenTarget;
+ }
+ TypeScriptCompiler.prototype.timeFunction = function (funcDescription, func) {
+ return TypeScript.timeFunction(this.logger, funcDescription, func);
+ };
+ TypeScriptCompiler.prototype.initTypeChecker = function (errorOutput) {
+ this.persistentTypeState.refreshPersistentState();
+ this.typeChecker = new TypeScript.TypeChecker(this.persistentTypeState);
+ this.typeChecker.errorReporter = this.errorReporter;
+ this.typeChecker.checkControlFlow = this.settings.controlFlow;
+ this.typeChecker.checkControlFlowUseDef = this.settings.controlFlowUseDef;
+ this.typeChecker.printControlFlowGraph = this.settings.printControlFlow;
+ this.typeChecker.errorsOnWith = this.settings.errorOnWith;
+ this.typeChecker.styleSettings = this.settings.styleSettings;
+ this.typeChecker.canCallDefinitionSignature = this.settings.canCallDefinitionSignature;
+ this.errorReporter.checker = this.typeChecker;
+ this.setErrorOutput(this.errorOutput);
+ };
+ TypeScriptCompiler.prototype.setErrorOutput = function (outerr) {
+ this.errorOutput = outerr;
+ this.errorReporter.setErrOut(outerr);
+ this.parser.outfile = outerr;
+ };
+ TypeScriptCompiler.prototype.emitCommentsToOutput = function () {
+ this.emitSettings = new TypeScript.EmitOptions(this.settings);
+ };
+ TypeScriptCompiler.prototype.setErrorCallback = function (fn) {
+ this.parser.errorCallback = fn;
+ };
+ TypeScriptCompiler.prototype.updateUnit = function (prog, filename, setRecovery) {
+ return this.updateSourceUnit(new TypeScript.StringSourceText(prog), filename, setRecovery);
+ };
+ TypeScriptCompiler.prototype.updateSourceUnit = function (sourceText, filename, setRecovery) {
+ var _this = this;
+ return this.timeFunction("updateSourceUnit(" + filename + ")", function () {
+ var updateResult = _this.partialUpdateUnit(sourceText, filename, setRecovery);
+ return _this.applyUpdateResult(updateResult);
+ });
+ };
+ TypeScriptCompiler.prototype.applyUpdateResult = function (updateResult) {
+ switch(updateResult.kind) {
+ case UpdateUnitKind.NoEdits:
+ return false;
+ case UpdateUnitKind.Unknown:
+ this.scripts.members[updateResult.unitIndex] = updateResult.script2;
+ this.units[updateResult.unitIndex] = updateResult.script2.locationInfo;
+ for(var i = 0, len = updateResult.parseErrors.length; i < len; i++) {
+ var e = updateResult.parseErrors[i];
+ if(this.parser.errorCallback) {
+ this.parser.errorCallback(e.minChar, e.limChar - e.minChar, e.message, e.unitIndex);
+ }
+ }
+ return true;
+ case UpdateUnitKind.EditsInsideSingleScope:
+ new TypeScript.IncrementalParser(this.logger).mergeTrees(updateResult);
+ return true;
+ }
+ };
+ TypeScriptCompiler.prototype.partialUpdateUnit = function (sourceText, filename, setRecovery) {
+ var _this = this;
+ return this.timeFunction("partialUpdateUnit(" + filename + ")", function () {
+ for(var i = 0, len = _this.units.length; i < len; i++) {
+ if(_this.units[i].filename == filename) {
+ if((_this.scripts.members[i]).isResident) {
+ return UpdateUnitResult.noEdits(i);
+ }
+ if(setRecovery) {
+ _this.parser.setErrorRecovery(null);
+ }
+ var updateResult;
+ var parseErrors = [];
+ var errorCapture = function (minChar, charLen, message, unitIndex) {
+ parseErrors.push(new ErrorEntry(unitIndex, minChar, minChar + charLen, message));
+ };
+ var svErrorCallback = _this.parser.errorCallback;
+ if(svErrorCallback) {
+ _this.parser.errorCallback = errorCapture;
+ }
+ var oldScript = _this.scripts.members[i];
+ var newScript = _this.parser.parse(sourceText, filename, i);
+ if(svErrorCallback) {
+ _this.parser.errorCallback = svErrorCallback;
+ }
+ updateResult = UpdateUnitResult.unknownEdits(oldScript, newScript, parseErrors);
+ return updateResult;
+ }
+ }
+ throw new Error("Unknown file \"" + filename + "\"");
+ });
+ };
+ TypeScriptCompiler.prototype.addUnit = function (prog, filename, keepResident, referencedFiles) {
+ if (typeof keepResident === "undefined") { keepResident = false; }
+ if (typeof referencedFiles === "undefined") { referencedFiles = []; }
+ return this.addSourceUnit(new TypeScript.StringSourceText(prog), filename, keepResident, referencedFiles);
+ };
+ TypeScriptCompiler.prototype.addSourceUnit = function (sourceText, filename, keepResident, referencedFiles) {
+ if (typeof referencedFiles === "undefined") { referencedFiles = []; }
+ var _this = this;
+ return this.timeFunction("addSourceUnit(" + filename + ", " + keepResident + ")", function () {
+ var script = _this.parser.parse(sourceText, filename, _this.units.length, TypeScript.AllowedElements.Global);
+ script.referencedFiles = referencedFiles;
+ script.isResident = keepResident;
+ _this.persistentTypeState.setCollectionMode(keepResident ? TypeScript.TypeCheckCollectionMode.Resident : TypeScript.TypeCheckCollectionMode.Transient);
+ var index = _this.units.length;
+ _this.units[index] = script.locationInfo;
+ _this.typeChecker.collectTypes(script);
+ _this.scripts.append(script);
+ return script;
+ });
+ };
+ TypeScriptCompiler.prototype.parseUnit = function (prog, filename) {
+ return this.parseSourceUnit(new TypeScript.StringSourceText(prog), filename);
+ };
+ TypeScriptCompiler.prototype.parseSourceUnit = function (sourceText, filename) {
+ this.parser.setErrorRecovery(this.errorOutput);
+ var script = this.parser.parse(sourceText, filename, 0);
+ var index = this.units.length;
+ this.units[index] = script.locationInfo;
+ this.typeChecker.collectTypes(script);
+ this.scripts.append(script);
+ };
+ TypeScriptCompiler.prototype.typeCheck = function () {
+ var _this = this;
+ return this.timeFunction("typeCheck()", function () {
+ var binder = new TypeScript.Binder(_this.typeChecker);
+ _this.typeChecker.units = _this.units;
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.globals);
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.ambientGlobals);
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.globalTypes);
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.ambientGlobalTypes);
+ _this.typeFlow = new TypeScript.TypeFlow(_this.logger, _this.typeChecker.globalScope, _this.parser, _this.typeChecker);
+ var i = 0;
+ var script = null;
+ var len = _this.scripts.members.length;
+ _this.persistentTypeState.setCollectionMode(TypeScript.TypeCheckCollectionMode.Resident);
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(!script.isResident || script.hasBeenTypeChecked) {
+ continue;
+ }
+ _this.typeFlow.assignScopes(script);
+ _this.typeFlow.initLibs();
+ }
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(!script.isResident || script.hasBeenTypeChecked) {
+ continue;
+ }
+ _this.typeFlow.typeCheck(script);
+ script.hasBeenTypeChecked = true;
+ }
+ _this.persistentTypeState.setCollectionMode(TypeScript.TypeCheckCollectionMode.Transient);
+ len = _this.scripts.members.length;
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(script.isResident) {
+ continue;
+ }
+ _this.typeFlow.assignScopes(script);
+ _this.typeFlow.initLibs();
+ }
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(script.isResident) {
+ continue;
+ }
+ _this.typeFlow.typeCheck(script);
+ }
+ return null;
+ });
+ };
+ TypeScriptCompiler.prototype.cleanASTTypesForReTypeCheck = function (ast) {
+ function cleanASTType(ast, parent) {
+ ast.type = null;
+ if(ast.nodeType == TypeScript.NodeType.VarDecl) {
+ var vardecl = ast;
+ vardecl.sym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.ArgDecl) {
+ var argdecl = ast;
+ argdecl.sym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.Name) {
+ var name = ast;
+ name.sym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.FuncDecl) {
+ var funcdecl = ast;
+ funcdecl.signature = null;
+ funcdecl.freeVariables = new Array();
+ funcdecl.symbols = null;
+ funcdecl.accessorSymbol = null;
+ funcdecl.scopeType = null;
+ } else if(ast.nodeType == TypeScript.NodeType.ModuleDeclaration) {
+ var modDecl = ast;
+ modDecl.mod = null;
+ } else if(ast.nodeType == TypeScript.NodeType.With) {
+ (ast).withSym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.Catch) {
+ (ast).containedScope = null;
+ } else if(ast.nodeType === TypeScript.NodeType.Script) {
+ (ast).externallyVisibleImportedSymbols = [];
+ }
+ 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, inputOutputMapper) {
+ 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, this.settings.emitFullSourceMapPath));
+ }
+ if(inputOutputMapper) {
+ inputOutputMapper(script.locationInfo.unitIndex, outFname);
+ }
+ } else if(this.settings.mapSourceFiles) {
+ emitter.setSourceMappings(new TypeScript.SourceMapper(fname, emitter.emittingFileName, emitter.outfile, emitter.sourceMapper.sourceMapOut, this.errorReporter, this.settings.emitFullSourceMapPath));
+ }
+ 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, inputOutputMapper) {
+ 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, null, inputOutputMapper);
+ } 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, getPrettyTypeName) {
+ 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, getPrettyTypeName);
+ this.compiler.typeChecker.currentModDecl = svModuleDecl;
+ return result;
+ };
+ ScopeTraversal.prototype.getTypeNamesForNames = function (enclosingScopeContext, allNames, scope, getPrettyTypeName) {
+ 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 getPrettyOverload = getPrettyTypeName && symbol.declAST && symbol.declAST.nodeType == TypeScript.NodeType.FuncDecl;
+ var type = symbol.getType();
+ var typeName = type ? type.getScopedTypeName(enclosingScope, getPrettyOverload) : "";
+ 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 = {}));
+if(!String.prototype.trim) {
+ String.prototype.trim = function () {
+ return this.replace(/^\s+|\s+$/g, '');
+ };
+}
+if(!Array.prototype.indexOf) {
+ Array.prototype.indexOf = function (searchElement, fromIndex) {
+ "use strict";
+ if(this == null) {
+ throw new TypeError();
+ }
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if(len === 0) {
+ return -1;
+ }
+ var n = 0;
+ if(arguments.length > 0) {
+ n = Number(arguments[1]);
+ if(n != n) {
+ n = 0;
+ } else if(n != 0 && n != Infinity && n != -Infinity) {
+ n = (n > 0 || -1) * Math.floor(Math.abs(n));
+ }
+ }
+ if(n >= len) {
+ return -1;
+ }
+ var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
+ for(; k < len; k++) {
+ if(k in t && t[k] === searchElement) {
+ return k;
+ }
+ }
+ return -1;
+ };
+}
+if(!Array.prototype.filter) {
+ Array.prototype.filter = function (fun, thisp) {
+ "use strict";
+ if(this == null) {
+ throw new TypeError();
+ }
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if(typeof fun != "function") {
+ throw new TypeError();
+ }
+ var res = [];
+ var thisp = arguments[1];
+ for(var i = 0; i < len; i++) {
+ if(i in t) {
+ var val = t[i];
+ if(fun.call(thisp, val, i, t)) {
+ res.push(val);
+ }
+ }
+ }
+ return res;
+ };
+}
+if(!Array.prototype.map) {
+ Array.prototype.map = function (callback, thisArg) {
+ var T = undefined, A, k;
+ if(this == null) {
+ throw new TypeError(" this is null or not defined");
+ }
+ var O = Object(this);
+ var len = O.length >>> 0;
+ if({
+ }.toString.call(callback) != "[object Function]") {
+ throw new TypeError(callback + " is not a function");
+ }
+ if(thisArg) {
+ T = thisArg;
+ }
+ A = new Array(len);
+ k = 0;
+ while(k < len) {
+ var kValue, mappedValue;
+ if(k in O) {
+ kValue = O[k];
+ mappedValue = callback.call(T, kValue, k, O);
+ A[k] = mappedValue;
+ }
+ k++;
+ }
+ return A;
+ };
+}
+if(!Array.prototype.reduce) {
+ Array.prototype.reduce = function reduce(accumulator) {
+ if(this === null || this === undefined) {
+ throw new TypeError("Object is null or undefined");
+ }
+ var i = 0, l = this.length >> 0, curr;
+ if(typeof accumulator !== "function") {
+ throw new TypeError("First argument is not callable");
+ }
+ if(arguments.length < 2) {
+ if(l === 0) {
+ throw new TypeError("Array length is 0 and no second argument");
+ }
+ curr = this[0];
+ i = 1;
+ } else {
+ curr = arguments[1];
+ }
+ while(i < l) {
+ if(i in this) {
+ curr = accumulator.call(undefined, curr, this[i], i, this);
+ }
+ ++i;
+ }
+ return curr;
+ };
+}
+if(!Array.prototype.forEach) {
+ Array.prototype.forEach = function (callback, thisArg) {
+ var T, k;
+ if(this == null) {
+ throw new TypeError(" this is null or not defined");
+ }
+ var O = Object(this);
+ var len = O.length >>> 0;
+ if({
+ }.toString.call(callback) != "[object Function]") {
+ throw new TypeError(callback + " is not a function");
+ }
+ if(thisArg) {
+ T = thisArg;
+ } else {
+ T = undefined;
+ }
+ k = 0;
+ while(k < len) {
+ var kValue;
+ if(k in O) {
+ kValue = O[k];
+ callback.call(T, kValue, k, O);
+ }
+ k++;
+ }
+ };
+}
+if(!Date.now) {
+ (Date).now = function () {
+ return +(new Date());
+ };
+}
+if(!Array.prototype.some) {
+ Array.prototype.some = function (fun) {
+ "use strict";
+ if(this == null) {
+ throw new TypeError();
+ }
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if(typeof fun != "function") {
+ throw new TypeError();
+ }
+ var thisp = arguments[1];
+ for(var i = 0; i < len; i++) {
+ var idx = i.toString();
+ if(idx in t && fun.call(thisp, t[i], i, t)) {
+ return true;
+ }
+ }
+ return false;
+ };
+}
+var Services;
+(function (Services) {
+ var Classifier = (function () {
+ function Classifier(host) {
+ this.host = host;
+ this.scanner = new TypeScript.Scanner();
+ }
+ Classifier.prototype.getClassificationsForLine = function (text, lexState) {
+ var result = new ClassificationResult();
+ result.initialState = lexState;
+ this.scanner.lexState = lexState;
+ this.scanner.setText(text, TypeScript.LexMode.Line);
+ var t = this.scanner.scanInLine();
+ while(t.tokenId != TypeScript.TokenID.EndOfFile) {
+ result.entries.push(new ClassificationInfo(this.scanner.pos, t.classification()));
+ t = this.scanner.scanInLine();
+ }
+ result.finalLexState = this.scanner.lexState;
+ return result;
+ };
+ return Classifier;
+ })();
+ Services.Classifier = Classifier;
+ var ClassificationResult = (function () {
+ function ClassificationResult() {
+ this.initialState = TypeScript.LexState.Start;
+ this.finalLexState = TypeScript.LexState.Start;
+ this.entries = [];
+ }
+ return ClassificationResult;
+ })();
+ Services.ClassificationResult = ClassificationResult;
+ var ClassificationInfo = (function () {
+ function ClassificationInfo(length, classification) {
+ this.length = length;
+ this.classification = classification;
+ }
+ return ClassificationInfo;
+ })();
+ Services.ClassificationInfo = ClassificationInfo;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ function logInternalError(logger, err) {
+ logger.log("*INTERNAL ERROR* - Exception in typescript services: " + err.message);
+ }
+ Services.logInternalError = logInternalError;
+ var SourceTextAdapter = (function () {
+ function SourceTextAdapter(host, scriptIndex) {
+ this.host = host;
+ this.scriptIndex = scriptIndex;
+ }
+ SourceTextAdapter.prototype.getText = function (start, end) {
+ return this.host.getScriptSourceText(this.scriptIndex, start, end);
+ };
+ SourceTextAdapter.prototype.getLength = function () {
+ return this.host.getScriptSourceLength(this.scriptIndex);
+ };
+ return SourceTextAdapter;
+ })();
+ Services.SourceTextAdapter = SourceTextAdapter;
+ var CachedSourceTextAdapter = (function () {
+ function CachedSourceTextAdapter(host, scriptIndex) {
+ this.length = host.getScriptSourceLength(scriptIndex);
+ this.text = host.getScriptSourceText(scriptIndex, 0, this.length);
+ }
+ CachedSourceTextAdapter.prototype.getText = function (start, end) {
+ return this.text.substring(start, end);
+ };
+ CachedSourceTextAdapter.prototype.getLength = function () {
+ return this.length;
+ };
+ return CachedSourceTextAdapter;
+ })();
+ Services.CachedSourceTextAdapter = CachedSourceTextAdapter;
+ var SourceTextRange = (function () {
+ function SourceTextRange(sourceText, minChar, limChar) {
+ this.sourceText = sourceText;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ }
+ SourceTextRange.prototype.getText = function (start, end) {
+ var actualStart = this.minChar + start;
+ var actualEnd = this.minChar + end;
+ if(actualEnd > this.limChar) {
+ actualEnd = this.limChar;
+ }
+ return this.sourceText.getText(actualStart, actualEnd);
+ };
+ SourceTextRange.prototype.getLength = function () {
+ return this.limChar - this.minChar;
+ };
+ return SourceTextRange;
+ })();
+ Services.SourceTextRange = SourceTextRange;
+ var ReferenceEntry = (function () {
+ function ReferenceEntry(unitIndex, ast, isWriteAccess) {
+ this.unitIndex = unitIndex;
+ this.ast = ast;
+ this.isWriteAccess = isWriteAccess;
+ }
+ ReferenceEntry.prototype.getHashCode = function () {
+ return TypeScript.combineHashes(TypeScript.numberHashFn(this.unitIndex), TypeScript.combineHashes(TypeScript.numberHashFn(this.ast.minChar), TypeScript.numberHashFn(this.ast.limChar)));
+ };
+ ReferenceEntry.prototype.equals = function (other) {
+ if(other === null || other === undefined) {
+ return false;
+ }
+ return (this.unitIndex === other.unitIndex) && (this.ast.minChar === other.ast.minChar) && (this.ast.limChar === other.ast.limChar);
+ };
+ return ReferenceEntry;
+ })();
+ Services.ReferenceEntry = ReferenceEntry;
+ var ReferenceEntrySet = (function () {
+ function ReferenceEntrySet() {
+ this.entries = [];
+ this.hashTable = new TypeScript.HashTable(101, function (r) {
+ return r.getHashCode();
+ }, function (r1, r2) {
+ return r1.equals(r2);
+ });
+ }
+ ReferenceEntrySet.prototype.getEntries = function () {
+ return this.entries;
+ };
+ ReferenceEntrySet.prototype.addAst = function (unitIndex, ast, isWriteAccess) {
+ var reference = new ReferenceEntry(unitIndex, ast, isWriteAccess);
+ if(this.hashTable.lookup(reference) !== null) {
+ return;
+ }
+ this.hashTable.add(reference, reference);
+ this.entries.push(reference);
+ };
+ ReferenceEntrySet.prototype.addSymbol = function (sym) {
+ var unitIndex = sym.unitIndex;
+ if(unitIndex < 0) {
+ return;
+ }
+ var ast = sym.declAST;
+ if(ast == null) {
+ return;
+ }
+ var symbolLocation;
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.InterfaceDeclaration:
+ symbolLocation = (ast).name;
+ break;
+ case TypeScript.NodeType.ClassDeclaration:
+ symbolLocation = (ast).name;
+ break;
+ case TypeScript.NodeType.ModuleDeclaration:
+ symbolLocation = (ast).name;
+ break;
+ case TypeScript.NodeType.VarDecl:
+ symbolLocation = (ast).id;
+ break;
+ case TypeScript.NodeType.FuncDecl:
+ symbolLocation = (ast).name;
+ break;
+ default:
+ symbolLocation = ast;
+ }
+ if(symbolLocation === null) {
+ symbolLocation = ast;
+ }
+ this.addAst(unitIndex, symbolLocation, false);
+ };
+ return ReferenceEntrySet;
+ })();
+ Services.ReferenceEntrySet = ReferenceEntrySet;
+ var NavigateToItem = (function () {
+ function NavigateToItem() {
+ this.name = "";
+ this.kind = "";
+ this.kindModifiers = "";
+ this.matchKind = "";
+ this.unitIndex = -1;
+ this.minChar = -1;
+ this.limChar = -1;
+ this.containerName = "";
+ this.containerKind = "";
+ }
+ return NavigateToItem;
+ })();
+ Services.NavigateToItem = NavigateToItem;
+ var NavigateToContext = (function () {
+ function NavigateToContext() {
+ this.options = new TypeScript.AstWalkOptions();
+ this.unitIndex = 0;
+ this.containerSymbols = [];
+ this.containerKinds = [];
+ this.containerASTs = [];
+ this.path = new TypeScript.AstPath();
+ this.result = [];
+ }
+ return NavigateToContext;
+ })();
+ Services.NavigateToContext = NavigateToContext;
+ var TextRange = (function () {
+ function TextRange(minChar, limChar) {
+ this.minChar = minChar;
+ this.limChar = limChar;
+ }
+ return TextRange;
+ })();
+ Services.TextRange = TextRange;
+ var TextEdit = (function () {
+ function TextEdit(minChar, limChar, text) {
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.text = text;
+ }
+ TextEdit.createInsert = function createInsert(pos, text) {
+ return new TextEdit(pos, pos, text);
+ };
+ TextEdit.createDelete = function createDelete(minChar, limChar) {
+ return new TextEdit(minChar, limChar, "");
+ };
+ TextEdit.createReplace = function createReplace(minChar, limChar, text) {
+ return new TextEdit(minChar, limChar, text);
+ };
+ return TextEdit;
+ })();
+ Services.TextEdit = TextEdit;
+ var EditorOptions = (function () {
+ function EditorOptions() {
+ this.IndentSize = 4;
+ this.TabSize = 4;
+ this.NewLineCharacter = "\r\n";
+ this.ConvertTabsToSpaces = true;
+ }
+ return EditorOptions;
+ })();
+ Services.EditorOptions = EditorOptions;
+ var FormatCodeOptions = (function (_super) {
+ __extends(FormatCodeOptions, _super);
+ function FormatCodeOptions() {
+ _super.apply(this, arguments);
+
+ this.InsertSpaceAfterCommaDelimiter = true;
+ this.InsertSpaceAfterSemicolonInForStatements = true;
+ this.InsertSpaceBeforeAndAfterBinaryOperators = true;
+ this.InsertSpaceAfterKeywordsInControlFlowStatements = true;
+ this.InsertSpaceAfterFunctionKeywordForAnonymousFunctions = false;
+ this.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis = false;
+ this.PlaceOpenBraceOnNewLineForFunctions = false;
+ this.PlaceOpenBraceOnNewLineForControlBlocks = false;
+ }
+ return FormatCodeOptions;
+ })(EditorOptions);
+ Services.FormatCodeOptions = FormatCodeOptions;
+ var GetReferencesContext = (function () {
+ function GetReferencesContext() {
+ this.scope = [];
+ }
+ return GetReferencesContext;
+ })();
+ Services.GetReferencesContext = GetReferencesContext;
+ var DefinitionInfo = (function () {
+ function DefinitionInfo(unitIndex, minChar, limChar, kind, name, containerKind, containerName) {
+ this.unitIndex = unitIndex;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.kind = kind;
+ this.name = name;
+ this.containerKind = containerKind;
+ this.containerName = containerName;
+ }
+ return DefinitionInfo;
+ })();
+ Services.DefinitionInfo = DefinitionInfo;
+ var TypeInfo = (function () {
+ function TypeInfo(memberName, docComment, fullSymbolName, kind, minChar, limChar) {
+ this.memberName = memberName;
+ this.docComment = docComment;
+ this.fullSymbolName = fullSymbolName;
+ this.kind = kind;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ }
+ return TypeInfo;
+ })();
+ Services.TypeInfo = TypeInfo;
+ var SpanInfo = (function () {
+ function SpanInfo(minChar, limChar, text) {
+ if (typeof text === "undefined") { text = null; }
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.text = text;
+ }
+ return SpanInfo;
+ })();
+ Services.SpanInfo = SpanInfo;
+ var SignatureInfo = (function () {
+ function SignatureInfo() { }
+ return SignatureInfo;
+ })();
+ Services.SignatureInfo = SignatureInfo;
+ var FormalSignatureInfo = (function () {
+ function FormalSignatureInfo() {
+ this.signatureGroup = [];
+ }
+ return FormalSignatureInfo;
+ })();
+ Services.FormalSignatureInfo = FormalSignatureInfo;
+ var FormalSignatureItemInfo = (function () {
+ function FormalSignatureItemInfo() {
+ this.parameters = [];
+ }
+ return FormalSignatureItemInfo;
+ })();
+ Services.FormalSignatureItemInfo = FormalSignatureItemInfo;
+ var FormalParameterInfo = (function () {
+ function FormalParameterInfo() { }
+ return FormalParameterInfo;
+ })();
+ Services.FormalParameterInfo = FormalParameterInfo;
+ var ActualSignatureInfo = (function () {
+ function ActualSignatureInfo() {
+ this.parameters = [];
+ }
+ return ActualSignatureInfo;
+ })();
+ Services.ActualSignatureInfo = ActualSignatureInfo;
+ var ActualParameterInfo = (function () {
+ function ActualParameterInfo() { }
+ return ActualParameterInfo;
+ })();
+ Services.ActualParameterInfo = ActualParameterInfo;
+ var CompletionInfo = (function () {
+ function CompletionInfo() {
+ this.maybeInaccurate = false;
+ this.isMemberCompletion = false;
+ this.entries = [];
+ }
+ return CompletionInfo;
+ })();
+ Services.CompletionInfo = CompletionInfo;
+ var CompletionEntry = (function () {
+ function CompletionEntry() {
+ this.name = "";
+ this.type = "";
+ this.kind = "";
+ this.kindModifiers = "";
+ this.fullSymbolName = "";
+ this.docComment = "";
+ }
+ return CompletionEntry;
+ })();
+ Services.CompletionEntry = CompletionEntry;
+ var ScriptElementKind = (function () {
+ function ScriptElementKind() { }
+ ScriptElementKind.unknown = "";
+ ScriptElementKind.keyword = "keyword";
+ ScriptElementKind.scriptElement = "script";
+ ScriptElementKind.moduleElement = "module";
+ ScriptElementKind.classElement = "class";
+ ScriptElementKind.interfaceElement = "interface";
+ ScriptElementKind.enumElement = "enum";
+ ScriptElementKind.variableElement = "var";
+ ScriptElementKind.localVariableElement = "local var";
+ ScriptElementKind.functionElement = "function";
+ ScriptElementKind.localFunctionElement = "local function";
+ ScriptElementKind.memberFunctionElement = "method";
+ ScriptElementKind.memberGetAccessorElement = "getter";
+ ScriptElementKind.memberSetAccessorElement = "setter";
+ ScriptElementKind.memberVariableElement = "property";
+ ScriptElementKind.constructorImplementationElement = "constructor";
+ ScriptElementKind.callSignatureElement = "call";
+ ScriptElementKind.indexSignatureElement = "index";
+ ScriptElementKind.constructSignatureElement = "construct";
+ ScriptElementKind.parameterElement = "parameter";
+ return ScriptElementKind;
+ })();
+ Services.ScriptElementKind = ScriptElementKind;
+ var ScriptElementKindModifier = (function () {
+ function ScriptElementKindModifier() { }
+ ScriptElementKindModifier.none = "";
+ ScriptElementKindModifier.publicMemberModifier = "public";
+ ScriptElementKindModifier.privateMemberModifier = "private";
+ ScriptElementKindModifier.exportedModifier = "export";
+ ScriptElementKindModifier.ambientModifier = "declare";
+ ScriptElementKindModifier.staticModifier = "static";
+ return ScriptElementKindModifier;
+ })();
+ Services.ScriptElementKindModifier = ScriptElementKindModifier;
+ var MatchKind = (function () {
+ function MatchKind() { }
+ MatchKind.none = null;
+ MatchKind.exact = "exact";
+ MatchKind.subString = "substring";
+ MatchKind.prefix = "prefix";
+ return MatchKind;
+ })();
+ Services.MatchKind = MatchKind;
+ var ScriptSyntaxASTState = (function () {
+ function ScriptSyntaxASTState() {
+ this.version = -1;
+ this.syntaxAST = null;
+ this.fileName = null;
+ }
+ return ScriptSyntaxASTState;
+ })();
+ Services.ScriptSyntaxASTState = ScriptSyntaxASTState;
+ var LanguageService = (function () {
+ function LanguageService(host) {
+ this.host = host;
+ this.logger = this.host;
+ this.compilerState = new Services.CompilerState(this.host);
+ this.syntaxASTState = new ScriptSyntaxASTState();
+ this.formattingRulesProvider = new Formatting.RulesProvider(this.logger);
+ }
+ LanguageService.prototype.refresh = function () {
+ var _this = this;
+ TypeScript.timeFunction(this.logger, "refresh()", function () {
+ _this.compilerState.refresh();
+ });
+ };
+ LanguageService.prototype.minimalRefresh = function () {
+ var _this = this;
+ TypeScript.timeFunction(this.logger, "minimalRefresh()", function () {
+ _this.compilerState.minimalRefresh();
+ });
+ };
+ LanguageService.prototype.getSymbolTree = function () {
+ this.refresh();
+ return this.compilerState.getSymbolTree();
+ };
+ LanguageService.prototype.getScriptSyntaxAST = function (fileName) {
+ this.minimalRefresh();
+ return this._getScriptSyntaxAST(fileName);
+ };
+ LanguageService.prototype._getScriptSyntaxAST = function (fileName) {
+ var _this = this;
+ return TypeScript.timeFunction(this.logger, "getScriptSyntaxAST(\"" + fileName + "\")", function () {
+ var version = _this.compilerState.getScriptVersion(fileName);
+ var syntaxAST = _this.syntaxASTState.syntaxAST;
+ if(syntaxAST === null || _this.syntaxASTState.fileName !== fileName) {
+ syntaxAST = _this.compilerState.getScriptSyntaxAST(fileName);
+ } else if(_this.syntaxASTState.version !== version) {
+ syntaxAST = _this.attemptIncrementalSyntaxAST(_this.syntaxASTState);
+ if(syntaxAST === null) {
+ syntaxAST = _this.compilerState.getScriptSyntaxAST(fileName);
+ }
+ }
+ _this.syntaxASTState.version = version;
+ _this.syntaxASTState.fileName = fileName;
+ _this.syntaxASTState.syntaxAST = syntaxAST;
+ return _this.syntaxASTState.syntaxAST;
+ });
+ };
+ LanguageService.prototype.attemptIncrementalSyntaxAST = function (syntaxASTState) {
+ var syntaxAST = syntaxASTState.syntaxAST;
+ var fileName = syntaxAST.getScriptId();
+ var newSourceText = this.compilerState.getSourceText2(fileName);
+ var editRange = this.compilerState.getScriptEditRangeSinceVersion(fileName, syntaxASTState.version);
+ if(editRange === null) {
+ return syntaxAST;
+ }
+ var incrementalParser = new TypeScript.IncrementalParser(this.logger);
+ var updateResult = incrementalParser.attemptIncrementalUpdateUnit(syntaxAST.getScript(), syntaxAST.getScriptId(), newSourceText, editRange);
+ if(updateResult !== null && updateResult.kind === TypeScript.UpdateUnitKind.EditsInsideSingleScope) {
+ incrementalParser.mergeTrees(updateResult);
+ return new Services.ScriptSyntaxAST(this.logger, updateResult.script1, newSourceText);
+ }
+ return null;
+ };
+ LanguageService.prototype.getScriptAST = function (fileName) {
+ this.refresh();
+ return this.compilerState.getScriptAST(fileName);
+ };
+ LanguageService.prototype.getTypeInfo = function (type, symbol, typeInfoAtPosition, enclosingScopeContext) {
+ var memberName = null;
+ var kind = "";
+ var docComment = "";
+ var symbolName = "";
+ var scopeSymbol = enclosingScopeContext.getScope();
+ if(typeInfoAtPosition.ast.nodeType == TypeScript.NodeType.Dot) {
+ return null;
+ }
+ if(symbol.declAST && symbol.declAST.nodeType == TypeScript.NodeType.FuncDecl && (symbol.declAST).accessorSymbol) {
+ symbol = (symbol.declAST).accessorSymbol;
+ type = symbol.getType();
+ }
+ if(typeInfoAtPosition.callSignature) {
+ var signatureGroup = null;
+ if(typeInfoAtPosition.isNew) {
+ signatureGroup = type.construct;
+ } else {
+ signatureGroup = type.call;
+ }
+ var memberNames = new TypeScript.MemberNameArray();
+ memberNames.addAll(signatureGroup.toStrings("", true, scopeSymbol, true, typeInfoAtPosition.callSignature));
+ memberName = memberNames;
+ if(typeInfoAtPosition.callSignature.declAST) {
+ docComment = TypeScript.Comment.getDocCommentText(typeInfoAtPosition.callSignature.declAST.getDocComments());
+ if(typeInfoAtPosition.callSignature.declAST.type.symbol.name != "_anonymous") {
+ symbol = typeInfoAtPosition.callSignature.declAST.type.symbol;
+ }
+ } else {
+ docComment = "";
+ }
+ kind = this.getSymbolElementKind(symbol, scopeSymbol, false);
+ if(kind == ScriptElementKind.interfaceElement || kind == ScriptElementKind.classElement) {
+ kind = typeInfoAtPosition.isNew ? ScriptElementKind.constructorImplementationElement : ScriptElementKind.functionElement;
+ }
+ } else {
+ memberName = type.getScopedTypeNameEx(scopeSymbol, true);
+ docComment = this.getDocCommentOfSymbol(symbol);
+ kind = this.getSymbolElementKind(symbol, scopeSymbol, true);
+ }
+ symbolName = symbol ? this.getFullNameOfSymbol(symbol, enclosingScopeContext) : "";
+ return new TypeInfo(memberName, docComment, symbolName, kind, typeInfoAtPosition.ast.minChar, typeInfoAtPosition.ast.limChar);
+ };
+ LanguageService.prototype.getTypeAtPosition = function (fileName, pos) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var sourceText = this.compilerState.getSourceText(script);
+ var typeInfo = this.getTypeInfoAtPosition(pos, script, true);
+ if(typeInfo == null) {
+ this.logger.log("No type found at the specified location.");
+ return null;
+ }
+ var enclosingScopeContext = TypeScript.findEnclosingScopeAt(this.logger, script, sourceText, pos, false);
+ if(enclosingScopeContext == null) {
+ this.logger.log("No context found at the specified location.");
+ return null;
+ }
+ if(typeInfo.symbol) {
+ return this.getTypeInfo(typeInfo.symbol.getType(), typeInfo.symbol, typeInfo, enclosingScopeContext);
+ } else if(typeInfo.ast.type) {
+ return this.getTypeInfo(typeInfo.ast.type, typeInfo.ast.type.symbol, typeInfo, enclosingScopeContext);
+ } else {
+ this.logger.log("No type found at the specified location.");
+ return null;
+ }
+ };
+ LanguageService.prototype.getNameOrDottedNameSpan = function (fileName, startPos, endPos) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var typeAndSpanInfo = this.getTypeInfoAtPosition(startPos, script);
+ if(typeAndSpanInfo == null) {
+ this.logger.log("No name or dotted name found at the specified location.");
+ return null;
+ }
+ return typeAndSpanInfo.spanInfo;
+ };
+ LanguageService.prototype.getBreakpointInStatement = function (pos, astSpan, verifyASTPos, existingResult, forceFirstStatement, isAst) {
+ if(existingResult || !astSpan || (verifyASTPos && pos > astSpan.limChar)) {
+ return existingResult;
+ }
+ if(!isAst) {
+ return astSpan;
+ }
+ var ast = astSpan;
+ var astList = null;
+ if(ast.nodeType == TypeScript.NodeType.Block) {
+ var block = ast;
+ astList = block.statements;
+ } else if(ast.nodeType == TypeScript.NodeType.List) {
+ astList = ast;
+ } else {
+ return ast;
+ }
+ if(astList.members.length > 0) {
+ var lastAST = astList.members[astList.members.length - 1];
+ if(!forceFirstStatement && pos > lastAST.limChar) {
+ return lastAST;
+ } else {
+ return astList.members[0];
+ }
+ }
+ return null;
+ };
+ LanguageService.prototype.getBreakpointStatementAtPosition = function (fileName, pos) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var containerASTs = [];
+ var lineMap = this.compilerState.getLineMap(fileName);
+ var lineCol = {
+ line: -1,
+ col: -1
+ };
+ TypeScript.getSourceLineColFromMap(lineCol, pos, lineMap);
+ var pre = function (cur, parent, walker) {
+ if(TypeScript.isValidAstNode(cur)) {
+ if(pos >= cur.minChar && pos <= cur.limChar) {
+ switch(cur.nodeType) {
+ case TypeScript.NodeType.ModuleDeclaration:
+ case TypeScript.NodeType.ClassDeclaration:
+ case TypeScript.NodeType.FuncDecl:
+ case TypeScript.NodeType.Break:
+ case TypeScript.NodeType.Continue:
+ containerASTs.push(cur);
+ break;
+ case TypeScript.NodeType.Script:
+ case TypeScript.NodeType.List:
+ case TypeScript.NodeType.NumberLit:
+ case TypeScript.NodeType.Regex:
+ case TypeScript.NodeType.QString:
+ case TypeScript.NodeType.ArrayLit:
+ case TypeScript.NodeType.ObjectLit:
+ case TypeScript.NodeType.TypeAssertion:
+ case TypeScript.NodeType.Pos:
+ case TypeScript.NodeType.Neg:
+ case TypeScript.NodeType.Not:
+ case TypeScript.NodeType.LogNot:
+ case TypeScript.NodeType.Block:
+ break;
+ case TypeScript.NodeType.TypeRef:
+ walker.options.goChildren = false;
+ break;
+ default:
+ if(cur.isStatementOrExpression() && (!cur.isExpression() || containerASTs.length == 0 || (!containerASTs[containerASTs.length - 1].isExpression() && containerASTs[containerASTs.length - 1].nodeType != TypeScript.NodeType.VarDecl || containerASTs[containerASTs.length - 1].nodeType == TypeScript.NodeType.ConditionalExpression))) {
+ containerASTs.push(cur);
+ }
+ break;
+ }
+ } else {
+ walker.options.goChildren = false;
+ }
+ }
+ return cur;
+ };
+ TypeScript.getAstWalkerFactory().walk(script, pre);
+ if(containerASTs.length == 0) {
+ return null;
+ }
+ var resultAST = null;
+ var cur = containerASTs[containerASTs.length - 1];
+ var customSpan = null;
+ switch(cur.nodeType) {
+ case TypeScript.NodeType.ModuleDeclaration:
+ var moduleDecl = cur;
+ if(containerASTs.length > 1) {
+ resultAST = moduleDecl;
+ } else {
+ resultAST = this.getBreakpointInStatement(pos, moduleDecl.members, false, null, false, true);
+ }
+ customSpan = moduleDecl.endingToken;
+ break;
+ case TypeScript.NodeType.FuncDecl:
+ var funcDecl = cur;
+ if(containerASTs.length > 1) {
+ resultAST = funcDecl;
+ } else {
+ resultAST = this.getBreakpointInStatement(pos, funcDecl.bod, false, null, false, true);
+ }
+ customSpan = funcDecl.endingToken;
+ break;
+ case TypeScript.NodeType.ClassDeclaration:
+ var classDecl = cur;
+ if(containerASTs.length > 1) {
+ resultAST = classDecl;
+ } else {
+ resultAST = this.getBreakpointInStatement(pos, classDecl.members, false, null, false, true);
+ }
+ customSpan = classDecl.endingToken;
+ break;
+ case TypeScript.NodeType.VarDecl:
+ var varDecl = cur;
+ if(varDecl.init) {
+ resultAST = varDecl;
+ }
+ break;
+ case TypeScript.NodeType.If:
+ var ifStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, ifStatement.statement, true, resultAST, false, false);
+ resultAST = this.getBreakpointInStatement(pos, ifStatement.thenBod, true, resultAST, false, true);
+ resultAST = this.getBreakpointInStatement(pos, ifStatement.elseBod, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.ForIn:
+ var forInStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, forInStatement.statement, true, resultAST, false, false);
+ resultAST = this.getBreakpointInStatement(pos, forInStatement.body, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.For:
+ var forStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, forStatement.init, true, null, false, true);
+ resultAST = this.getBreakpointInStatement(pos, forStatement.cond, true, resultAST, false, true);
+ resultAST = this.getBreakpointInStatement(pos, forStatement.incr, true, resultAST, false, true);
+ resultAST = this.getBreakpointInStatement(pos, forStatement.body, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.While:
+ var whileStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, whileStatement.cond, true, null, false, true);
+ resultAST = this.getBreakpointInStatement(pos, whileStatement.body, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.DoWhile:
+ var doWhileStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, doWhileStatement.body, true, null, false, true);
+ resultAST = this.getBreakpointInStatement(pos, doWhileStatement.cond, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.Switch:
+ var switchStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, switchStatement.statement, true, resultAST, false, false);
+ var caseListCount = switchStatement.caseList.members.length;
+ if(caseListCount > 0) {
+ var lastCase = switchStatement.caseList.members[caseListCount - 1];
+ if(pos >= lastCase.limChar) {
+ var caseToUse = lastCase;
+ resultAST = this.getBreakpointInStatement(pos, caseToUse.body.members[0], false, resultAST, false, true);
+ } else {
+ var caseToUse = switchStatement.caseList.members[0];
+ resultAST = this.getBreakpointInStatement(pos, caseToUse.body.members[0], false, resultAST, true, true);
+ }
+ }
+ break;
+ case TypeScript.NodeType.Case:
+ var caseStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, caseStatement.body.members[0], false, null, false, true);
+ break;
+ case TypeScript.NodeType.With:
+ var withStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, withStatement.body, false, null, false, true);
+ break;
+ case TypeScript.NodeType.Try:
+ var tryNode = cur;
+ resultAST = this.getBreakpointInStatement(pos, tryNode.body, false, null, false, true);
+ break;
+ case TypeScript.NodeType.Catch:
+ var catchNode = cur;
+ resultAST = this.getBreakpointInStatement(pos, catchNode.statement, true, null, false, false);
+ resultAST = this.getBreakpointInStatement(pos, catchNode.body, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.Finally:
+ var finallyNode = cur;
+ resultAST = this.getBreakpointInStatement(pos, finallyNode, false, null, false, true);
+ break;
+ case TypeScript.NodeType.TryCatch:
+ var tryCatch = cur;
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.tryNode.body, true, null, false, true);
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.catchNode.statement, true, resultAST, false, false);
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.catchNode.body, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.TryFinally:
+ var tryFinally = cur;
+ if(tryFinally.nodeType == TypeScript.NodeType.Try) {
+ resultAST = this.getBreakpointInStatement(pos, (tryFinally.tryNode).body, true, null, false, true);
+ } else {
+ var tryCatch = tryFinally.tryNode;
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.tryNode.body, true, null, false, true);
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.catchNode.statement, true, resultAST, false, false);
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.catchNode.body, true, resultAST, false, true);
+ }
+ resultAST = this.getBreakpointInStatement(pos, tryFinally.finallyNode, false, resultAST, false, true);
+ break;
+ default:
+ resultAST = cur;
+ break;
+ }
+ if(TypeScript.isValidAstNode(customSpan) && pos >= customSpan.minChar && pos <= customSpan.limChar) {
+ resultAST = customSpan;
+ }
+ if(resultAST) {
+ var result = new SpanInfo(resultAST.minChar, resultAST.limChar);
+ return result;
+ }
+ return null;
+ };
+ LanguageService.prototype.getSignatureAtPosition = function (fileName, pos) {
+ var _this = this;
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var atEOF = (pos === script.limChar);
+ var path = this.getAstPathToPosition(script, pos);
+ if(path.count() == 0) {
+ return null;
+ }
+ if(path.nodeType() === TypeScript.NodeType.Comment) {
+ this.logger.log("position is inside a comment");
+ return null;
+ }
+ var callExpr = null;
+ while(path.count() >= 2) {
+ if(path.isArgumentListOfCall() || path.isArgumentListOfNew()) {
+ if(atEOF || pos > path.ast().minChar) {
+ path.pop();
+ callExpr = path.pop();
+ }
+ break;
+ }
+ if(pos > path.ast().minChar) {
+ if(path.ast().nodeType !== TypeScript.NodeType.Error && path.ast().nodeType !== TypeScript.NodeType.List) {
+ break;
+ }
+ }
+ path.pop();
+ }
+ if(!callExpr || !callExpr.target || !callExpr.target.type) {
+ this.logger.log("No call expression for the given position");
+ return null;
+ }
+ if(callExpr.target.type === this.compilerState.anyType()) {
+ this.logger.log("Call expression is of type 'any'");
+ return null;
+ }
+ var sourceText = this.compilerState.getSourceText(script);
+ var enclosingScopeContext = TypeScript.findEnclosingScopeAt(this.logger, script, sourceText, pos, false);
+ if(enclosingScopeContext == null) {
+ this.logger.log("No context found at the specified location.");
+ return null;
+ }
+ var getNameFromSymbol = function (symbol) {
+ if(symbol != null && symbol.name != "_anonymous") {
+ return symbol.name;
+ }
+ return "";
+ };
+ var getDocCommentFromSymbol = function (symbol) {
+ if(symbol != null) {
+ return TypeScript.Comment.getDocCommentText(symbol.getDocComments());
+ }
+ return "";
+ };
+ var convertSignatureGroupToSignatureInfo = function (symbol, isNew, group) {
+ var result = new FormalSignatureInfo();
+ result.isNew = false;
+ result.name = getNameFromSymbol(symbol);
+ result.docComment = getDocCommentFromSymbol(symbol);
+ result.openParen = (group.flags & TypeScript.SignatureFlags.IsIndexer ? "[" : "(");
+ result.closeParen = (group.flags & TypeScript.SignatureFlags.IsIndexer ? "]" : ")");
+ var hasOverloads = group.signatures.length > 1;
+ group.signatures.filter(function (signature) {
+ return !(hasOverloads && signature === group.definitionSignature && !_this.compilerState.getCompilationSettings().canCallDefinitionSignature);
+ }).forEach(function (signature) {
+ var signatureGroupInfo = new FormalSignatureItemInfo();
+ signatureGroupInfo.docComment = (signature.declAST != null) ? TypeScript.Comment.getDocCommentText(signature.declAST.getDocComments()) : "";
+ signatureGroupInfo.returnType = (signature.returnType === null ? "any" : signature.returnType.type.getScopedTypeName(enclosingScopeContext.getScope()));
+ signature.parameters.forEach(function (p, i) {
+ var signatureParameterInfo = new FormalParameterInfo();
+ signatureParameterInfo.isVariable = (signature.hasVariableArgList) && (i === signature.parameters.length - 1);
+ signatureParameterInfo.isOptional = p.isOptional();
+ signatureParameterInfo.name = p.name;
+ signatureParameterInfo.docComment = p.getParameterDocComments();
+ signatureParameterInfo.type = p.getType().getScopedTypeName(enclosingScopeContext.getScope());
+ signatureGroupInfo.parameters.push(signatureParameterInfo);
+ });
+ result.signatureGroup.push(signatureGroupInfo);
+ });
+ return result;
+ };
+ var convertCallExprToActualSignatureInfo = function (ast, caretPosition) {
+ if(!TypeScript.isValidAstNode(ast)) {
+ return null;
+ }
+ if(!TypeScript.isValidAstNode(ast.arguments)) {
+ return null;
+ }
+ var result = new ActualSignatureInfo();
+ result.currentParameter = -1;
+ result.openParenMinChar = ast.arguments.minChar;
+ result.closeParenLimChar = Math.max(ast.arguments.minChar, ast.arguments.limChar);
+ ast.arguments.members.forEach(function (arg, index) {
+ var parameter = new ActualParameterInfo();
+ parameter.minChar = arg.minChar;
+ parameter.limChar = Math.max(arg.minChar, arg.limChar);
+ result.parameters.push(parameter);
+ });
+ result.parameters.forEach(function (p, index) {
+ var minChar = (index == 0 ? result.openParenMinChar : result.parameters[index - 1].limChar + 1);
+ var limChar = (index == result.parameters.length - 1 ? result.closeParenLimChar : result.parameters[index + 1].minChar);
+ if(caretPosition >= minChar && (atEOF ? caretPosition <= limChar : caretPosition < limChar)) {
+ result.currentParameter = index;
+ }
+ });
+ return result;
+ };
+ var getSignatureIndex = function (ast, group) {
+ if(ast == null || group == null || group.signatures == null) {
+ return -1;
+ }
+ return group.signatures.indexOf(ast.signature);
+ };
+ var getTargetSymbolWithName = function (callExpr) {
+ var sym = null;
+ if((callExpr.target).sym != null) {
+ sym = (callExpr.target).sym;
+ } else if(callExpr.target.type.symbol !== null) {
+ var sym = callExpr.target.type.symbol;
+ }
+ if(sym != null) {
+ if(sym.kind() == TypeScript.SymbolKind.Type && ((sym).isMethod || (sym).isClass() || (sym).isFunction()) && (sym.name != null)) {
+ return sym;
+ } else if(sym.kind() == TypeScript.SymbolKind.Parameter) {
+ return sym;
+ } else if(sym.kind() == TypeScript.SymbolKind.Variable) {
+ return sym;
+ } else if(sym.kind() == TypeScript.SymbolKind.Field) {
+ return sym;
+ }
+ }
+ return null;
+ };
+ var symbol = getTargetSymbolWithName(callExpr);
+ var result = new SignatureInfo();
+ if(callExpr.nodeType === TypeScript.NodeType.Call && callExpr.target.type.call !== null) {
+ result.formal = convertSignatureGroupToSignatureInfo(symbol, false, callExpr.target.type.call);
+ result.actual = convertCallExprToActualSignatureInfo(callExpr, pos);
+ result.activeFormal = getSignatureIndex(callExpr, callExpr.target.type.call);
+ } else if(callExpr.nodeType === TypeScript.NodeType.New && callExpr.target.type.construct !== null) {
+ result.formal = convertSignatureGroupToSignatureInfo(symbol, true, callExpr.target.type.construct);
+ result.actual = convertCallExprToActualSignatureInfo(callExpr, pos);
+ result.activeFormal = getSignatureIndex(callExpr, callExpr.target.type.construct);
+ } else if(callExpr.target.nodeType === TypeScript.NodeType.Super && callExpr.target.type.symbol && callExpr.target.type.symbol.declAST) {
+ var classType = callExpr.target.type.symbol.declAST.type;
+ if(classType && classType.construct !== null) {
+ result.formal = convertSignatureGroupToSignatureInfo(symbol, true, classType.construct);
+ result.actual = convertCallExprToActualSignatureInfo(callExpr, pos);
+ result.activeFormal = getSignatureIndex(callExpr, classType.construct);
+ } else {
+ this.logger.log("No signature group found for the target class type constructor");
+ return null;
+ }
+ } else {
+ this.logger.log("No signature group found for the target of the call expression");
+ return null;
+ }
+ if(result.actual == null || result.formal == null || result.activeFormal == null) {
+ this.logger.log("Can't compute actual and/or formal signature of the call expression");
+ return null;
+ }
+ return result;
+ };
+ LanguageService.prototype.getDefinitionAtPosition = function (fileName, pos) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var sym = this.getSymbolAtPosition(script, pos);
+ if(sym == null) {
+ this.logger.log("No identifier at the specified location.");
+ return null;
+ }
+ if(!TypeScript.isValidAstNode(sym.declAST)) {
+ this.logger.log("No symbol location for identifier at the specified location.");
+ return null;
+ }
+ var unitIndex = sym.unitIndex;
+ var minChar = sym.declAST.minChar;
+ var limChar = sym.declAST.limChar;
+ return new DefinitionInfo(this.compilerState.mapToHostUnitIndex(unitIndex), minChar, limChar, this.getSymbolElementKind(sym), sym.name, this.getSymbolContainerKind(sym), this.getSymbolContainerName(sym));
+ };
+ LanguageService.prototype.getSmartIndentAtLineNumber = function (fileName, lineNumber, options) {
+ this.minimalRefresh();
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.SmartIndentManager(syntaxAST, options);
+ return manager.getSmartIndentAtLineNumber(lineNumber);
+ };
+ LanguageService.prototype.getBraceMatchingAtPosition = function (fileName, position) {
+ this.minimalRefresh();
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Services.BraceMatchingManager(syntaxAST);
+ return manager.getBraceMatchingAtPosition(position);
+ };
+ LanguageService.prototype.getFullNameOfSymbol = function (symbol, enclosingScopeContext) {
+ if(symbol && symbol.container && symbol.container.declAST && symbol.container.declAST.nodeType == TypeScript.NodeType.FuncDecl) {
+ var funcDecl = symbol.container.declAST;
+ if(funcDecl.symbols.lookup(symbol.name) == symbol) {
+ return symbol.getPrettyName(enclosingScopeContext.getScope().container);
+ }
+ }
+ if(symbol && symbol.kind() == TypeScript.SymbolKind.Type) {
+ var typeSymbol = symbol;
+ if(typeSymbol.type && typeSymbol.type.symbol == symbol && typeSymbol.type.primitiveTypeClass != TypeScript.Primitive.None) {
+ return "";
+ }
+ }
+ return symbol.fullName(enclosingScopeContext.getScope());
+ };
+ LanguageService.prototype.getSymbolElementKind = function (sym, scopeSymbol, useConstructorAsClass) {
+ if(!sym) {
+ return ScriptElementKind.unknown;
+ }
+ if(sym.declAST == null) {
+ return ScriptElementKind.keyword;
+ }
+ var isLocal = function () {
+ if(sym.container && sym.container.declAST && sym.container.declAST.nodeType == TypeScript.NodeType.FuncDecl) {
+ if(scopeSymbol && scopeSymbol.container == sym.container) {
+ return true;
+ }
+ }
+ return false;
+ };
+ var ast = sym.declAST;
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.InterfaceDeclaration:
+ return ScriptElementKind.interfaceElement;
+ case TypeScript.NodeType.ClassDeclaration:
+ return ScriptElementKind.classElement;
+ case TypeScript.NodeType.ModuleDeclaration:
+ var moduleDecl = ast;
+ var isEnum = moduleDecl.isEnum();
+ return isEnum ? ScriptElementKind.enumElement : ScriptElementKind.moduleElement;
+ case TypeScript.NodeType.ImportDeclaration:
+ return ScriptElementKind.moduleElement;
+ case TypeScript.NodeType.VarDecl:
+ var varDecl = ast;
+ if(varDecl.isProperty()) {
+ return ScriptElementKind.memberVariableElement;
+ }
+ return isLocal() ? ScriptElementKind.localVariableElement : ScriptElementKind.variableElement;
+ case TypeScript.NodeType.ArgDecl:
+ var argDecl = ast;
+ if(sym.kind() == TypeScript.SymbolKind.Parameter) {
+ return ScriptElementKind.parameterElement;
+ }
+ return (argDecl.isProperty() ? ScriptElementKind.memberVariableElement : ScriptElementKind.variableElement);
+ case TypeScript.NodeType.FuncDecl:
+ var funcDecl = ast;
+ if(funcDecl.isGetAccessor()) {
+ return ScriptElementKind.memberGetAccessorElement;
+ } else if(funcDecl.isSetAccessor()) {
+ return ScriptElementKind.memberSetAccessorElement;
+ } else if(funcDecl.isCallMember()) {
+ return ScriptElementKind.callSignatureElement;
+ } else if(funcDecl.isIndexerMember()) {
+ return ScriptElementKind.indexSignatureElement;
+ } else if(funcDecl.isConstructMember()) {
+ return ScriptElementKind.constructSignatureElement;
+ } else if(funcDecl.isConstructor) {
+ return useConstructorAsClass ? ScriptElementKind.classElement : ScriptElementKind.constructorImplementationElement;
+ } else if(funcDecl.isMethod()) {
+ return ScriptElementKind.memberFunctionElement;
+ } else if(isLocal()) {
+ return ScriptElementKind.localFunctionElement;
+ } else {
+ return ScriptElementKind.functionElement;
+ }
+ default:
+ if(this.logger.warning()) {
+ this.logger.log("Warning: unrecognized AST node type: " + (TypeScript.NodeType)._map[ast.nodeType]);
+ }
+ return ScriptElementKind.unknown;
+ }
+ };
+ LanguageService.prototype.getSymbolElementKindModifiers = function (sym) {
+ if(sym.declAST == null) {
+ return ScriptElementKindModifier.none;
+ }
+ return this.getDeclNodeElementKindModifiers(sym.declAST);
+ };
+ LanguageService.prototype.getSymbolContainerKind = function (sym) {
+ return "";
+ };
+ LanguageService.prototype.getSymbolContainerName = function (sym) {
+ return sym.container == null ? "" : sym.container.fullName();
+ };
+ LanguageService.prototype.getReferencesAtPosition = function (fileName, pos) {
+ this.refresh();
+ var context = new GetReferencesContext();
+ for(var i = 0, len = this.compilerState.getScriptCount(); i < len; i++) {
+ context.scope.push(i);
+ }
+ return this.getReferencesForSourceLocation(context, this.compilerState.getUnitIndex(fileName), pos);
+ };
+ LanguageService.prototype.getOccurrencesAtPosition = function (fileName, pos) {
+ this.refresh();
+ var unitIndex = this.compilerState.getUnitIndex(fileName);
+ var context = new GetReferencesContext();
+ context.scope.push(unitIndex);
+ return this.getReferencesForSourceLocation(context, unitIndex, pos);
+ };
+ LanguageService.prototype.getImplementorsAtPosition = function (fileName, position) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var path = this.getIdentifierPathToPosition(script, position);
+ if(path === null) {
+ this.logger.log("No identifier at the specified location.");
+ return [];
+ }
+ var name = path.ast();
+ var sym = name.sym;
+ if(sym === null) {
+ this.logger.log("No symbol annotation on the identifier AST.");
+ return [];
+ }
+ var collector = new Services.OverridesCollector(this.getSymbolTree());
+ var symbolSet = collector.findImplementors(sym);
+ var references = new ReferenceEntrySet();
+ symbolSet.getAll().forEach(function (x) {
+ references.addSymbol(x);
+ });
+ return this.mapUnitIndexInReferenceEntrySet(references);
+ };
+ LanguageService.prototype.getReferencesForSourceLocation = function (context, unitIndex, position) {
+ var script = this.compilerState.getScript(unitIndex);
+ var path = this.getIdentifierPathToPosition(script, position);
+ if(path === null) {
+ this.logger.log("No identifier at the specified location.");
+ return [];
+ }
+ var name = path.ast();
+ var sym = name.sym;
+ if(sym === null) {
+ this.logger.log("No symbol annotation on the identifier AST.");
+ return [];
+ }
+ return this.getReferencesForSymbol(context, sym);
+ };
+ LanguageService.prototype.isWriteAccess = function (parent, cur) {
+ var write = false;
+ if(parent !== null) {
+ var pnt = parent.nodeType;
+ switch(pnt) {
+ case TypeScript.NodeType.VarDecl:
+ if((parent).init != null) {
+ write = true;
+ }
+ break;
+ case TypeScript.NodeType.ArgDecl:
+ write = true;
+ break;
+ case TypeScript.NodeType.Asg:
+ 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:
+ case TypeScript.NodeType.AsgXor:
+ case TypeScript.NodeType.AsgLsh:
+ case TypeScript.NodeType.AsgRsh:
+ case TypeScript.NodeType.AsgRs2:
+ if((parent).operand1 === cur) {
+ write = true;
+ }
+ break;
+ case TypeScript.NodeType.IncPost:
+ case TypeScript.NodeType.IncPre:
+ case TypeScript.NodeType.DecPost:
+ case TypeScript.NodeType.DecPre:
+ write = true;
+ break;
+ }
+ }
+ return write;
+ };
+ LanguageService.prototype.getReferencesForSymbol = function (context, sym) {
+ var _this = this;
+ var collector = new Services.OverridesCollector(this.getSymbolTree());
+ var symbolSet = collector.findMemberOverrides(sym);
+ var references = new ReferenceEntrySet();
+ var match = function (unitIndex, parent, cur) {
+ references.addAst(unitIndex, cur, _this.isWriteAccess(parent, cur));
+ };
+ if(sym.kind() == TypeScript.SymbolKind.Field) {
+ this.logger.log("getReferencesToField");
+ this.getReferencesToField(context, symbolSet, match);
+ } else if(sym.kind() == TypeScript.SymbolKind.Parameter) {
+ this.logger.log("getReferencesToParameter");
+ this.getReferencesToParameter(context, symbolSet, match);
+ } else if(sym.kind() == TypeScript.SymbolKind.Type) {
+ this.logger.log("getReferencesToType");
+ this.getReferencesToType(context, symbolSet, match);
+ } else if(sym.kind() == TypeScript.SymbolKind.Variable) {
+ this.logger.log("getReferencesToVariable");
+ this.getReferencesToVariable(context, symbolSet, match);
+ } else {
+ this.logger.log("No recognized symbol at the specified location (" + sym.kind() + ").");
+ }
+ return this.mapUnitIndexInReferenceEntrySet(references);
+ };
+ LanguageService.prototype.mapUnitIndexInReferenceEntrySet = function (references) {
+ var _this = this;
+ var result = references.getEntries();
+ result.forEach(function (x) {
+ x.unitIndex = _this.compilerState.mapToHostUnitIndex(x.unitIndex);
+ });
+ return result;
+ };
+ LanguageService.prototype.getCompletionsAtPosition = function (fileName, pos, isMemberCompletion) {
+ this.refresh();
+ var result = this.getQuickCompletionsAtPosition(fileName, pos, isMemberCompletion);
+ if(result == null) {
+ this.refresh();
+ result = this.getAccurateCompletionsAtPosition(fileName, pos, isMemberCompletion);
+ }
+ return result;
+ };
+ LanguageService.prototype.getQuickCompletionsAtPosition = function (fileName, pos, isMemberCompletion) {
+ var script = this.compilerState.getScriptAST(fileName);
+ var editRange = this.compilerState.getScriptEditRange(script);
+ if(editRange == null) {
+ this.logger.log("Full refresh required: there are no pending edits for the script. Be conservative and try again with accurate algorithm.");
+ return null;
+ }
+ var sourceText = this.compilerState.getSourceText(script);
+ var enclosingScopeContext = new TypeScript.IncrementalParser(this.logger).getEnclosingScopeContextIfSingleScopeEdit(script, fileName, sourceText, editRange);
+ if(enclosingScopeContext === null) {
+ this.logger.log("Full refresh required: range of edits may affect more than one scope");
+ return null;
+ }
+ if(enclosingScopeContext.enclosingObjectLit !== null) {
+ this.logger.log("Full refresh required: quick completion list does not work inside object literals, because full typecheck is required to obtain the target type of the object literal.");
+ return null;
+ }
+ enclosingScopeContext.pos = pos;
+ enclosingScopeContext.isMemberCompletion = isMemberCompletion;
+ this.logger.log("Found scope context in previous script AST: " + editRange + ", pos=" + pos + ", scopePos=" + enclosingScopeContext.getScopePosition());
+ var result = new CompletionInfo();
+ result.maybeInaccurate = true;
+ result.isMemberCompletion = isMemberCompletion;
+ enclosingScopeContext.useFullAst = false;
+ this.getCompletionsFromEnclosingScopeContext(enclosingScopeContext, result);
+ if(result.entries.length == 0) {
+ this.logger.log("Full refresh required: QuickCompletion returned an empty list. Be conservative and try again with accurate algorithm.");
+ return null;
+ }
+ return result;
+ };
+ LanguageService.prototype.getAccurateCompletionsAtPosition = function (fileName, pos, isMemberCompletion) {
+ var result = new CompletionInfo();
+ result.maybeInaccurate = false;
+ result.isMemberCompletion = isMemberCompletion;
+ var script = this.compilerState.getScriptAST(fileName);
+ var sourceText = this.compilerState.getSourceText(script);
+ var enclosingScopeContext = TypeScript.findEnclosingScopeAt(this.logger, script, sourceText, pos, isMemberCompletion);
+ if(enclosingScopeContext == null) {
+ this.logger.log("No context found at the specified location.");
+ return result;
+ }
+ this.logger.log("Found scope context in up-to-date script AST: pos=" + pos + ", scopePos=" + enclosingScopeContext.getScopePosition());
+ enclosingScopeContext.useFullAst = true;
+ this.getCompletionsFromEnclosingScopeContext(enclosingScopeContext, result);
+ return result;
+ };
+ LanguageService.prototype.getDocCommentOfSymbol = function (symbol) {
+ if(!symbol) {
+ return "";
+ }
+ var type = symbol.getType();
+ if(type && type.isClass() && type.symbol.name == symbol.name) {
+ return TypeScript.Comment.getDocCommentText(type.getDocComments());
+ }
+ if(symbol.declAST && symbol.declAST.nodeType == TypeScript.NodeType.FuncDecl && type.call && type.call.signatures.length > 1) {
+ return TypeScript.Comment.getDocCommentFirstOverloadSignature(type.call);
+ }
+ if(symbol.kind() == TypeScript.SymbolKind.Parameter) {
+ return (symbol).getParameterDocComments();
+ }
+ if(symbol.declAST && symbol.declAST.nodeType == TypeScript.NodeType.ArgDecl && (symbol.declAST).isProperty()) {
+ return ((symbol.declAST).sym).getParameterDocComments();
+ }
+ return TypeScript.Comment.getDocCommentText(symbol.getDocComments());
+ };
+ LanguageService.prototype.getCompletionsFromEnclosingScopeContext = function (enclosingScopeContext, result) {
+ var _this = this;
+ var getCompletions = function (isMemberCompletion) {
+ result.isMemberCompletion = isMemberCompletion;
+ enclosingScopeContext.isMemberCompletion = isMemberCompletion;
+ var entries = _this.compilerState.getScopeEntries(enclosingScopeContext, true);
+ entries.forEach(function (x) {
+ var entry = new CompletionEntry();
+ entry.name = x.name;
+ entry.type = x.type;
+ entry.kind = _this.getSymbolElementKind(x.sym, enclosingScopeContext.getScope(), true);
+ entry.fullSymbolName = _this.getFullNameOfSymbol(x.sym, enclosingScopeContext);
+ entry.docComment = _this.getDocCommentOfSymbol(x.sym);
+ entry.kindModifiers = _this.getSymbolElementKindModifiers(x.sym);
+ result.entries.push(entry);
+ });
+ };
+ var scriptFragment = enclosingScopeContext.getScriptFragment();
+ try {
+ var path = this.getAstPathToPosition(scriptFragment, enclosingScopeContext.pos - enclosingScopeContext.getScriptFragmentPosition(), TypeScript.GetAstPathOptions.EdgeInclusive | TypeScript.GetAstPathOptions.DontPruneSearchBasedOnPosition);
+ if(this.isCompletionListBlocker(path)) {
+ this.logger.log("Returning an empty list because position is inside a comment");
+ } else if(this.isObjectLiteralMemberNameCompletion(enclosingScopeContext)) {
+ this.logger.log("Completion list for members of object literal");
+ return getCompletions(true);
+ } else if(enclosingScopeContext.isMemberCompletion || this.isCompletionListTriggerPoint(path)) {
+ return getCompletions(enclosingScopeContext.isMemberCompletion);
+ } else {
+ this.logger.log("Returning an empty list because position is not a valid position for displaying a completion list");
+ }
+ }finally {
+ this.compilerState.cleanASTTypesForReTypeCheck(scriptFragment);
+ }
+ };
+ LanguageService.prototype.isObjectLiteralMemberNameCompletion = function (enclosingScopeContext) {
+ if(enclosingScopeContext.enclosingObjectLit === null) {
+ return false;
+ }
+ if(enclosingScopeContext.isMemberCompletion) {
+ return false;
+ }
+ var objectLit = enclosingScopeContext.enclosingObjectLit;
+ var script = enclosingScopeContext.script;
+ var pos = enclosingScopeContext.pos;
+ if(!TypeScript.isValidAstNode(objectLit)) {
+ return false;
+ }
+ if(!TypeScript.isValidAstNode(objectLit.operand)) {
+ return false;
+ }
+ if(objectLit.operand.nodeType !== TypeScript.NodeType.List) {
+ return false;
+ }
+ var memberList = objectLit.operand;
+ var isInsideList = (memberList.minChar < pos && pos < memberList.limChar);
+ if(!isInsideList) {
+ return false;
+ }
+ if(memberList.members.length == 0) {
+ return true;
+ }
+ var syntaxAST = new Services.ScriptSyntaxAST(this.logger, script, enclosingScopeContext.text);
+ var tokenStream = new Services.TokenStreamHelper(syntaxAST.getTokenStream(memberList.minChar, memberList.limChar));
+ var nameAreaMinChar = tokenStream.tokenEndPos();
+ var isNameArea = false;
+ var cancelSearch = false;
+ if(!tokenStream.expect(TypeScript.TokenID.OpenBrace)) {
+ return false;
+ }
+ memberList.members.forEach(function (x, i) {
+ if(cancelSearch) {
+ return;
+ }
+ if(x.nodeType !== TypeScript.NodeType.Member) {
+ nameAreaMinChar = -1;
+ return;
+ }
+ var member = x;
+ if(!TypeScript.isValidAstNode(member.operand1)) {
+ nameAreaMinChar = -1;
+ return;
+ }
+ if(nameAreaMinChar < 0) {
+ nameAreaMinChar = member.operand1.minChar;
+ }
+ if(!tokenStream.skipToOffset(member.operand1.limChar)) {
+ nameAreaMinChar = -1;
+ cancelSearch = true;
+ return;
+ }
+ if(tokenStream.tokenId() !== TypeScript.TokenID.Colon) {
+ nameAreaMinChar = -1;
+ return;
+ }
+ if((nameAreaMinChar) >= 0 && (nameAreaMinChar <= pos) && (pos <= tokenStream.tokenStartPos())) {
+ isNameArea = true;
+ cancelSearch = true;
+ return;
+ }
+ nameAreaMinChar = -1;
+ if(TypeScript.isValidAstNode(member.operand2)) {
+ if(tokenStream.skipToOffset(member.operand2.limChar)) {
+ if(tokenStream.tokenId() == TypeScript.TokenID.Comma) {
+ nameAreaMinChar = tokenStream.tokenEndPos();
+ tokenStream.moveNext();
+ }
+ }
+ }
+ });
+ if(nameAreaMinChar < 0) {
+ return false;
+ }
+ if(isNameArea) {
+ return true;
+ }
+ if(tokenStream.tokenId() !== TypeScript.TokenID.CloseBrace) {
+ return false;
+ }
+ return (nameAreaMinChar <= pos) && (pos <= tokenStream.tokenStartPos());
+ };
+ LanguageService.prototype.isCompletionListBlocker = function (path) {
+ var asts = path.asts;
+ var isNodeType = function (nodeType) {
+ return (path.count() >= 1) && (path.ast().nodeType === nodeType);
+ };
+ if(isNodeType(TypeScript.NodeType.Comment) || isNodeType(TypeScript.NodeType.Regex) || isNodeType(TypeScript.NodeType.QString)) {
+ return true;
+ }
+ return false;
+ };
+ LanguageService.prototype.isCompletionListTriggerPoint = function (path) {
+ var asts = path.asts;
+ var isNodeType = function (nodeType) {
+ return (path.count() >= 1) && (path.ast().nodeType === nodeType);
+ };
+ var isDecl = function (nodeType) {
+ if(isNodeType(nodeType)) {
+ return true;
+ }
+ if(asts.length > 1 && (asts[asts.length - 2].nodeType === nodeType) && (asts[asts.length - 1].nodeType === TypeScript.NodeType.Name)) {
+ return true;
+ }
+ return false;
+ };
+ if(path.isNameOfVariable() || path.isNameOfFunction() || path.isNameOfArgument() || path.isArgumentListOfFunction() || path.isNameOfInterface() || path.isNameOfClass() || path.isNameOfModule()) {
+ return false;
+ }
+ if(isNodeType(TypeScript.NodeType.Member) || isNodeType(TypeScript.NodeType.TryCatch) || isNodeType(TypeScript.NodeType.Catch) || isNodeType(TypeScript.NodeType.Comment) || isNodeType(TypeScript.NodeType.Regex) || isNodeType(TypeScript.NodeType.QString)) {
+ return false;
+ }
+ return true;
+ };
+ LanguageService.prototype.getFormattingEditsForRange = function (fileName, minChar, limChar, options) {
+ this.minimalRefresh();
+ this.formattingRulesProvider.ensureUptodate(options);
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ var result = manager.FormatSelection(minChar, limChar);
+ if(this.logger.information()) {
+ this.logFormatCodeOptions(options);
+ this.logEditResults(syntaxAST, result);
+ }
+ return result;
+ };
+ LanguageService.prototype.getFormattingEditsForDocument = function (fileName, minChar, limChar, options) {
+ this.minimalRefresh();
+ this.formattingRulesProvider.ensureUptodate(options);
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ var result = manager.FormatDocument(minChar, limChar);
+ if(this.logger.information()) {
+ this.logEditResults(syntaxAST, result);
+ }
+ return result;
+ };
+ LanguageService.prototype.getFormattingEditsOnPaste = function (fileName, minChar, limChar, options) {
+ this.minimalRefresh();
+ this.formattingRulesProvider.ensureUptodate(options);
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ var result = manager.FormatOnPaste(minChar, limChar);
+ if(this.logger.information()) {
+ this.logEditResults(syntaxAST, result);
+ }
+ return result;
+ };
+ LanguageService.prototype.getFormattingEditsAfterKeystroke = function (fileName, position, key, options) {
+ this.minimalRefresh();
+ this.formattingRulesProvider.ensureUptodate(options);
+ if(key === "}") {
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ return manager.FormatOnClosingCurlyBrace(position);
+ } else if(key === ";") {
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ return manager.FormatOnSemicolon(position);
+ } else if(key === "\n") {
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ return manager.FormatOnEnter(position);
+ }
+ return [];
+ };
+ LanguageService.prototype.getNavigateToItems = function (searchValue) {
+ this.refresh();
+ var terms = searchValue.split(" ");
+ for(var i = 0; i < terms.length; i++) {
+ terms[i] = terms[i].trim().toLocaleLowerCase();
+ }
+ var match = function (ast, parent, name) {
+ name = name.toLocaleLowerCase();
+ for(var i = 0; i < terms.length; i++) {
+ var term = terms[i];
+ if(name === term) {
+ return MatchKind.exact;
+ }
+ if(name.indexOf(term) == 0) {
+ return MatchKind.prefix;
+ }
+ if(name.indexOf(term) > 0) {
+ return MatchKind.subString;
+ }
+ }
+ return null;
+ };
+ var result = [];
+ for(var i = 0, len = this.compilerState.getScriptCount(); i < len; i++) {
+ var script = this.compilerState.getScript(i);
+ var scriptId = script.locationInfo.filename;
+ var matchKind = match(null, script, scriptId);
+ if(matchKind != null) {
+ var item = new NavigateToItem();
+ item.name = scriptId;
+ item.matchKind = matchKind;
+ item.kind = ScriptElementKind.scriptElement;
+ item.unitIndex = this.compilerState.mapToHostUnitIndex(i);
+ item.minChar = script.minChar;
+ item.limChar = script.limChar;
+ result.push(item);
+ }
+ var items = this.getASTItems(i, script, match);
+ for(var j = 0; j < items.length; j++) {
+ result.push(items[j]);
+ }
+ }
+ return result;
+ };
+ LanguageService.prototype.getScriptLexicalStructure = function (fileName) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ return this.getASTItems(script.locationInfo.unitIndex, script, function (name) {
+ return MatchKind.exact;
+ });
+ };
+ LanguageService.prototype.getOutliningRegions = function (fileName) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var maxLim = function (current) {
+ var asts = [];
+ for (var _i = 0; _i < (arguments.length - 1); _i++) {
+ asts[_i] = arguments[_i + 1];
+ }
+ var maxLim1 = function (current, asts) {
+ var result = current;
+ for(var i = 0; i < asts.length; i++) {
+ var ast = asts[i];
+ if(ast != null && ast.limChar != 0 && ast.limChar > result) {
+ result = ast.limChar;
+ }
+ }
+ return result;
+ };
+ var result = maxLim1(current, asts);
+ for(var i = 0; i < asts.length; i++) {
+ var ast = asts[i];
+ if(ast != null && ast.nodeType == TypeScript.NodeType.List) {
+ result = maxLim1(result, (ast).members);
+ }
+ }
+ return result;
+ };
+ var findMinChar = function (parent, ast) {
+ var result = ast.minChar;
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.FuncDecl:
+ result = maxLim(result, (ast).name, (ast).arguments, (ast).returnTypeAnnotation);
+ break;
+ case TypeScript.NodeType.ModuleDeclaration:
+ result = maxLim(result, (ast).name);
+ break;
+ case TypeScript.NodeType.ClassDeclaration:
+ result = maxLim(result, (ast).name, (ast).extendsList, (ast).implementsList);
+ break;
+ case TypeScript.NodeType.InterfaceDeclaration:
+ result = maxLim(result, (ast).name, (ast).extendsList, (ast).implementsList);
+ break;
+ }
+ return result;
+ };
+ var findLimChar = function (parent, ast) {
+ return ast.limChar;
+ };
+ var match = function (parent, ast, name) {
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.FuncDecl:
+ if((ast).bod == null) {
+ return MatchKind.none;
+ }
+ case TypeScript.NodeType.ClassDeclaration:
+ case TypeScript.NodeType.ModuleDeclaration:
+ case TypeScript.NodeType.InterfaceDeclaration:
+ return MatchKind.exact;
+ default:
+ return null;
+ }
+ };
+ return this.getASTItems(script.locationInfo.unitIndex, script, match, findMinChar, findLimChar);
+ };
+ LanguageService.prototype.logAST = function (fileName) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ new TypeScript.AstLogger(this.logger).logScript(script);
+ };
+ LanguageService.prototype.logSyntaxAST = function (fileName) {
+ this.minimalRefresh();
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ new TypeScript.AstLogger(this.logger).logScript(syntaxAST.getScript());
+ };
+ LanguageService.prototype.getErrors = function (maxCount) {
+ this.compilerState.refresh(false);
+ return this.compilerState.getErrorEntries(maxCount, function (u, e) {
+ return true;
+ });
+ };
+ LanguageService.prototype.getScriptErrors = function (fileName, maxCount) {
+ this.refresh();
+ var unitIndex = this.compilerState.getUnitIndex(fileName);
+ return this.compilerState.getErrorEntries(maxCount, function (u, e) {
+ return u === unitIndex;
+ });
+ };
+ LanguageService.prototype.getEmitOutput = function (fileName) {
+ this.refresh();
+ return this.compilerState.getEmitOutput(fileName);
+ };
+ LanguageService.prototype.getTypeInfoAtPosition = function (pos, script, constructorIsValid) {
+ var result = null;
+ var callExpr = [];
+ var createTypeInfoAtPosition = function (minChar, limChar, ast, type, forceNew) {
+ var typeInfoAtPosition = {
+ spanInfo: new SpanInfo(minChar, limChar),
+ ast: ast
+ };
+ if(callExpr.length > 0) {
+ var curCallExpr = callExpr[callExpr.length - 1];
+ if(curCallExpr.target.type == type) {
+ typeInfoAtPosition.callSignature = curCallExpr.signature;
+ typeInfoAtPosition.isNew = forceNew || curCallExpr.nodeType == TypeScript.NodeType.New;
+ }
+ }
+ return typeInfoAtPosition;
+ };
+ var pre = function (cur, parent) {
+ if(TypeScript.isValidAstNode(cur)) {
+ if(pos >= cur.minChar && pos < cur.limChar) {
+ switch(cur.nodeType) {
+ case TypeScript.NodeType.Call:
+ case TypeScript.NodeType.New:
+ var curCallExpr = cur;
+ if(pos >= curCallExpr.target.minChar && pos < curCallExpr.target.limChar) {
+ callExpr.push(curCallExpr);
+ }
+ break;
+ case TypeScript.NodeType.Dot:
+ if(result == null) {
+ result = createTypeInfoAtPosition(cur.minChar, cur.limChar, cur, cur.type);
+ }
+ break;
+ case TypeScript.NodeType.Name:
+ result = createTypeInfoAtPosition(result == null ? cur.minChar : result.spanInfo.minChar, cur.limChar, cur, (cur).sym ? (cur).sym.getType() : cur.type);
+ result.symbol = (cur).sym;
+ break;
+ case TypeScript.NodeType.FuncDecl:
+ var funcDecl = cur;
+ if(constructorIsValid && funcDecl.constructorSpan && pos >= funcDecl.constructorSpan.minChar && pos < funcDecl.constructorSpan.limChar) {
+ result = {
+ spanInfo: new SpanInfo(funcDecl.constructorSpan.minChar, funcDecl.constructorSpan.limChar),
+ ast: cur,
+ callSignature: funcDecl.signature,
+ isNew: true
+ };
+ }
+ break;
+ case TypeScript.NodeType.Super:
+ result = createTypeInfoAtPosition(cur.minChar, cur.limChar, cur, cur.type, true);
+ result.symbol = cur.type.symbol;
+ break;
+ case TypeScript.NodeType.QString:
+ case TypeScript.NodeType.This:
+ result = createTypeInfoAtPosition(cur.minChar, cur.limChar, cur, cur.type);
+ break;
+ }
+ } else if(result && callExpr.length > 0) {
+ var curCallExpr = callExpr[callExpr.length - 1];
+ if(curCallExpr.target.minChar >= cur.minChar && curCallExpr.target.minChar < cur.limChar) {
+ result.callSignature = null;
+ }
+ }
+ }
+ return cur;
+ };
+ var post = function (cur, parent) {
+ var callExprLength = callExpr.length;
+ if(callExprLength > 0 && callExpr[callExprLength - 1] == parent) {
+ callExpr.pop();
+ }
+ return cur;
+ };
+ TypeScript.getAstWalkerFactory().walk(script, pre, post);
+ return result;
+ };
+ LanguageService.prototype.getReferencesToField = function (context, symbolSet, match) {
+ var fieldMatch = function (unitIndex, parent, cur) {
+ if(cur.nodeType == TypeScript.NodeType.Name) {
+ match(unitIndex, parent, cur);
+ }
+ };
+ return this.getReferencesToSymbolSet(context, symbolSet, fieldMatch);
+ };
+ LanguageService.prototype.getReferencesToType = function (context, symbolSet, match) {
+ var typeMatch = function (unitIndex, parent, cur) {
+ if(cur.nodeType == TypeScript.NodeType.Name) {
+ match(unitIndex, parent, cur);
+ }
+ };
+ return this.getReferencesToSymbolSet(context, symbolSet, typeMatch);
+ };
+ LanguageService.prototype.getReferencesToParameter = function (context, symbolSet, match) {
+ var parameterMatch = function (unitIndex, parent, cur) {
+ if(cur.nodeType == TypeScript.NodeType.Name) {
+ match(unitIndex, parent, cur);
+ }
+ };
+ return this.getReferencesToSymbolSet(context, symbolSet, parameterMatch);
+ };
+ LanguageService.prototype.getReferencesToVariable = function (context, symbolSet, match) {
+ var variableMatch = function (unitIndex, parent, cur) {
+ if(cur.nodeType == TypeScript.NodeType.Name) {
+ match(unitIndex, parent, cur);
+ }
+ };
+ return this.getReferencesToSymbolSet(context, symbolSet, variableMatch);
+ };
+ LanguageService.prototype.getReferencesToSymbolSet = function (context, symbolSet, match) {
+ var _this = this;
+ var processScript = function (unitIndex) {
+ var pre = function (cur, parent) {
+ if(TypeScript.isValidAstNode(cur)) {
+ var sym = (cur).sym;
+ if(sym != null && symbolSet.contains(sym)) {
+ match(unitIndex, parent, cur);
+ }
+ }
+ return cur;
+ };
+ TypeScript.getAstWalkerFactory().walk(_this.compilerState.getScript(unitIndex), pre);
+ };
+ for(var i = 0, len = context.scope.length; i < len; i++) {
+ processScript(context.scope[i]);
+ }
+ };
+ LanguageService.prototype.getDeclNodeElementKindModifiers = function (ast) {
+ var addModifier = function (result, testValue, value) {
+ if(!testValue) {
+ return result;
+ }
+ if(result === ScriptElementKindModifier.none) {
+ return value;
+ } else {
+ return result + "," + value;
+ }
+ };
+ var typeDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isExported(), ScriptElementKindModifier.exportedModifier);
+ result = addModifier(result, decl.isAmbient(), ScriptElementKindModifier.ambientModifier);
+ return result;
+ };
+ var classDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isExported(), ScriptElementKindModifier.exportedModifier);
+ result = addModifier(result, decl.isAmbient(), ScriptElementKindModifier.ambientModifier);
+ return result;
+ };
+ var moduleDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isExported(), ScriptElementKindModifier.exportedModifier);
+ result = addModifier(result, decl.isAmbient(), ScriptElementKindModifier.ambientModifier);
+ return result;
+ };
+ var varDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isExported(), ScriptElementKindModifier.exportedModifier);
+ result = addModifier(result, decl.isAmbient(), ScriptElementKindModifier.ambientModifier);
+ result = addModifier(result, decl.isPublic(), ScriptElementKindModifier.publicMemberModifier);
+ result = addModifier(result, decl.isPrivate(), ScriptElementKindModifier.privateMemberModifier);
+ result = addModifier(result, decl.isStatic(), ScriptElementKindModifier.staticModifier);
+ return result;
+ };
+ var argDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isPublic(), ScriptElementKindModifier.publicMemberModifier);
+ result = addModifier(result, decl.isPrivate(), ScriptElementKindModifier.privateMemberModifier);
+ return result;
+ };
+ var funcDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isExported(), ScriptElementKindModifier.exportedModifier);
+ result = addModifier(result, decl.isAmbient(), ScriptElementKindModifier.ambientModifier);
+ result = addModifier(result, decl.isPublic(), ScriptElementKindModifier.publicMemberModifier);
+ result = addModifier(result, decl.isPrivate(), ScriptElementKindModifier.privateMemberModifier);
+ result = addModifier(result, decl.isStatic(), ScriptElementKindModifier.staticModifier);
+ return result;
+ };
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.InterfaceDeclaration:
+ var typeDecl = ast;
+ return typeDeclToKindModifiers(typeDecl);
+ case TypeScript.NodeType.ClassDeclaration:
+ var classDecl = ast;
+ return classDeclToKindModifiers(classDecl);
+ case TypeScript.NodeType.ModuleDeclaration:
+ var moduleDecl = ast;
+ return moduleDeclToKindModifiers(moduleDecl);
+ case TypeScript.NodeType.VarDecl:
+ var varDecl = ast;
+ return varDeclToKindModifiers(varDecl);
+ case TypeScript.NodeType.ArgDecl:
+ var argDecl = ast;
+ return argDeclToKindModifiers(argDecl);
+ case TypeScript.NodeType.FuncDecl:
+ var funcDecl = ast;
+ return funcDeclToKindModifiers(funcDecl);
+ default:
+ if(this.logger.warning()) {
+ this.logger.log("Warning: unrecognized AST node type: " + (TypeScript.NodeType)._map[ast.nodeType]);
+ }
+ return ScriptElementKindModifier.none;
+ }
+ };
+ LanguageService.prototype.getASTItems = function (unitIndex, ast, match, findMinChar, findLimChar) {
+ var _this = this;
+ if(findMinChar == null) {
+ findMinChar = function (parent, ast) {
+ return ast.minChar;
+ };
+ }
+ if(findLimChar == null) {
+ findLimChar = function (parent, ast) {
+ return ast.limChar;
+ };
+ }
+ var context = new NavigateToContext();
+ context.unitIndex = unitIndex;
+ var addItem = function (parent, ast, name, kind) {
+ if(!TypeScript.isValidAstNode(ast)) {
+ return null;
+ }
+ var matchKind = match(parent, ast, name);
+ var minChar = findMinChar(parent, ast);
+ var limChar = findLimChar(parent, ast);
+ if(matchKind != null && minChar >= 0 && limChar >= 0 && limChar >= minChar) {
+ var item = new NavigateToItem();
+ item.name = name;
+ item.matchKind = matchKind;
+ item.kind = kind;
+ item.kindModifiers = _this.getDeclNodeElementKindModifiers(ast);
+ item.unitIndex = _this.compilerState.mapToHostUnitIndex(context.unitIndex);
+ item.minChar = minChar;
+ item.limChar = limChar;
+ item.containerName = (TypeScript.lastOf(context.containerSymbols) === null ? "" : TypeScript.lastOf(context.containerSymbols).fullName());
+ item.containerKind = TypeScript.lastOf(context.containerKinds) === null ? "" : TypeScript.lastOf(context.containerKinds);
+ return item;
+ }
+ return null;
+ };
+ var getLimChar = function (ast) {
+ return (ast == null ? -1 : ast.limChar);
+ };
+ var pre = function (ast, parent, walker) {
+ context.path.push(ast);
+ if(!TypeScript.isValidAstNode(ast)) {
+ return ast;
+ }
+ var item = null;
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.InterfaceDeclaration:
+ {
+ var typeDecl = ast;
+ item = addItem(parent, typeDecl, typeDecl.name.actualText, ScriptElementKind.interfaceElement);
+ context.containerASTs.push(ast);
+ context.containerSymbols.push(typeDecl.type.symbol);
+ context.containerKinds.push("interface");
+ }
+ break;
+ case TypeScript.NodeType.ClassDeclaration:
+ {
+ var classDecl = ast;
+ item = addItem(parent, classDecl, classDecl.name.actualText, ScriptElementKind.classElement);
+ context.containerASTs.push(ast);
+ context.containerSymbols.push(classDecl.type.symbol);
+ context.containerKinds.push("class");
+ }
+ break;
+ case TypeScript.NodeType.ModuleDeclaration:
+ {
+ var moduleDecl = ast;
+ var isEnum = moduleDecl.isEnum();
+ var kind = isEnum ? ScriptElementKind.enumElement : ScriptElementKind.moduleElement;
+ item = addItem(parent, moduleDecl, moduleDecl.name.actualText, kind);
+ context.containerASTs.push(ast);
+ context.containerSymbols.push(moduleDecl.mod.symbol);
+ context.containerKinds.push(kind);
+ }
+ break;
+ case TypeScript.NodeType.VarDecl:
+ {
+ var varDecl = ast;
+ if(varDecl.id !== null) {
+ if(varDecl.isProperty()) {
+ item = addItem(parent, varDecl, varDecl.id.actualText, ScriptElementKind.memberVariableElement);
+ } else if(context.path.isChildOfScript() || context.path.isChildOfModule()) {
+ item = addItem(parent, varDecl, varDecl.id.actualText, ScriptElementKind.variableElement);
+ }
+ }
+ }
+ walker.options.goChildren = false;
+ break;
+ case TypeScript.NodeType.ArgDecl:
+ {
+ var argDecl = ast;
+ if(argDecl.id !== null) {
+ if(context.path.isArgumentOfClassConstructor()) {
+ if(argDecl.isProperty()) {
+ item = addItem(parent, argDecl, argDecl.id.actualText, ScriptElementKind.memberVariableElement);
+ }
+ }
+ }
+ }
+ walker.options.goChildren = false;
+ break;
+ case TypeScript.NodeType.FuncDecl:
+ {
+ var funcDecl = ast;
+ var kind = null;
+ var name = (funcDecl.name !== null ? funcDecl.name.actualText : null);
+ if(funcDecl.isGetAccessor()) {
+ kind = ScriptElementKind.memberGetAccessorElement;
+ } else if(funcDecl.isSetAccessor()) {
+ kind = ScriptElementKind.memberSetAccessorElement;
+ } else if(funcDecl.isCallMember()) {
+ kind = ScriptElementKind.callSignatureElement;
+ name = "()";
+ } else if(funcDecl.isIndexerMember()) {
+ kind = ScriptElementKind.indexSignatureElement;
+ name = "[]";
+ } else if(funcDecl.isConstructMember()) {
+ kind = ScriptElementKind.constructSignatureElement;
+ name = "new()";
+ } else if(funcDecl.isConstructor) {
+ kind = ScriptElementKind.constructorImplementationElement;
+ name = "constructor";
+ } else if(funcDecl.isMethod()) {
+ kind = ScriptElementKind.memberFunctionElement;
+ } else if(context.path.isChildOfScript() || context.path.isChildOfModule()) {
+ kind = ScriptElementKind.functionElement;
+ }
+ if(kind !== null && name !== null) {
+ item = addItem(parent, funcDecl, name, kind);
+ }
+ }
+ break;
+ case TypeScript.NodeType.ObjectLit:
+ walker.options.goChildren = false;
+ break;
+ }
+ if(item !== null) {
+ context.result.push(item);
+ }
+ return ast;
+ };
+ var post = function (ast, parent) {
+ context.path.pop();
+ if(ast === TypeScript.lastOf(context.containerASTs)) {
+ context.containerASTs.pop();
+ context.containerSymbols.pop();
+ context.containerKinds.pop();
+ }
+ return ast;
+ };
+ TypeScript.getAstWalkerFactory().walk(ast, pre, post);
+ return context.result;
+ };
+ LanguageService.prototype.getAstPathToPosition = function (script, pos, options) {
+ if (typeof options === "undefined") { options = TypeScript.GetAstPathOptions.Default; }
+ if(this.logger.information()) {
+ this.logger.log("getAstPathToPosition(" + script + ", " + pos + ")");
+ }
+ var path = TypeScript.getAstPathToPosition(script, pos, options);
+ if(this.logger.information()) {
+ if(path.count() == 0) {
+ this.logger.log("getAstPathToPosition: no ast found at position");
+ } else {
+ new TypeScript.AstLogger(this.logger).logNode(script, path.ast(), 0);
+ }
+ }
+ return path;
+ };
+ LanguageService.prototype.getIdentifierPathToPosition = function (script, pos) {
+ this.logger.log("getIdentifierPathToPosition(" + script + ", " + pos + ")");
+ var path = this.getAstPathToPosition(script, pos, TypeScript.GetAstPathOptions.EdgeInclusive);
+ if(path.count() == 0) {
+ return null;
+ }
+ if(path.nodeType() !== TypeScript.NodeType.Name) {
+ return null;
+ }
+ return path;
+ };
+ LanguageService.prototype.getSymbolAtPosition = function (script, pos) {
+ this.logger.log("getSymbolAtPosition(" + script + ", " + pos + ")");
+ var path = this.getAstPathToPosition(script, pos);
+ if(path.count() == 0) {
+ return null;
+ }
+ var finalAST = path.ast();
+ if(finalAST == null) {
+ return null;
+ }
+ if(finalAST.sym) {
+ return finalAST.sym;
+ }
+ if(finalAST.nodeType == TypeScript.NodeType.Dot && finalAST.operand2.sym) {
+ return finalAST.operand2.sym;
+ }
+ if(finalAST.signature && finalAST.signature.returnType && finalAST.signature.returnType.type && finalAST.signature.returnType.type.symbol) {
+ return finalAST.signature.returnType.type.symbol;
+ }
+ if(finalAST.type && finalAST.type.symbol) {
+ return finalAST.type.symbol;
+ }
+ return null;
+ };
+ LanguageService.prototype.logFormatCodeOptions = function (options) {
+ if(this.logger.information()) {
+ this.logger.log("options.InsertSpaceAfterCommaDelimiter=" + options.InsertSpaceAfterCommaDelimiter);
+ this.logger.log("options.InsertSpaceAfterSemicolonInForStatements=" + options.InsertSpaceAfterSemicolonInForStatements);
+ this.logger.log("options.InsertSpaceBeforeAndAfterBinaryOperators=" + options.InsertSpaceBeforeAndAfterBinaryOperators);
+ this.logger.log("options.InsertSpaceAfterKeywordsInControlFlowStatements=" + options.InsertSpaceAfterKeywordsInControlFlowStatements);
+ this.logger.log("options.InsertSpaceAfterFunctionKeywordForAnonymousFunctions=" + options.InsertSpaceAfterFunctionKeywordForAnonymousFunctions);
+ this.logger.log("options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis=" + options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis);
+ this.logger.log("options.PlaceOpenBraceOnNewLineForFunctions=" + options.PlaceOpenBraceOnNewLineForFunctions);
+ this.logger.log("options.PlaceOpenBraceOnNewLineForControlBlocks=" + options.PlaceOpenBraceOnNewLineForControlBlocks);
+ }
+ };
+ LanguageService.prototype.logEditResults = function (syntaxAST, result) {
+ var _this = this;
+ if(this.logger.information()) {
+ var logSourceText = function (text) {
+ var textLines = text.replace(/^\s+|\s+$/g, "").replace(/\r\n?/g, "\n").split(/\n/);
+ for(var i = 0; i < textLines.length; i++) {
+ var textLine = textLines[i];
+ var msg = "line #" + i + "(length=" + textLine.length + "): \"" + textLine + "\"";
+ _this.logger.log(msg);
+ }
+ };
+ var sourceText = syntaxAST.getSourceText();
+ logSourceText(sourceText.getText(0, sourceText.getLength()));
+ for(var i = 0; i < result.length; i++) {
+ var edit = result[i];
+ var oldSourceText = sourceText.getText(edit.minChar, edit.limChar);
+ var text = "edit #" + i + ": minChar=" + edit.minChar + ", " + "limChar=" + edit.limChar + ", " + "oldText=\"" + TypeScript.stringToLiteral(oldSourceText, 30) + "\", " + "textLength=" + edit.text.length + ", " + "text=\"" + TypeScript.stringToLiteral(edit.text, 30) + "\"";
+ this.logger.log(text);
+ }
+ }
+ };
+ return LanguageService;
+ })();
+ Services.LanguageService = LanguageService;
+})(Services || (Services = {}));
+var Formatting;
+(function (Formatting) {
+ var SnapshotSpan = (function () {
+ function SnapshotSpan(snapshot, span) {
+ this.snapshot = snapshot;
+ this.span = span;
+ this._startPoint = null;
+ this._endPoint = null;
+ }
+ SnapshotSpan.prototype.start = function () {
+ if(this._startPoint == null) {
+ this._startPoint = new SnapshotPoint(this.snapshot, this.span.start());
+ }
+ return this._startPoint;
+ };
+ SnapshotSpan.prototype.end = function () {
+ if(this._endPoint == null) {
+ this._endPoint = new SnapshotPoint(this.snapshot, this.span.end());
+ }
+ return this._endPoint;
+ };
+ SnapshotSpan.prototype.startPosition = function () {
+ return this.span.start();
+ };
+ SnapshotSpan.prototype.endPosition = function () {
+ return this.span.end();
+ };
+ SnapshotSpan.prototype.GetText = function () {
+ return this.snapshot.GetText(this.span);
+ };
+ SnapshotSpan.prototype.IsEmpty = function () {
+ return this.span.length() === 0;
+ };
+ SnapshotSpan.prototype.OverlapsWith = function (spanArg) {
+ return this.span.OverlapsWith(spanArg);
+ };
+ SnapshotSpan.prototype.Intersection = function (simpleSpan) {
+ var nullable = this.span.Intersection(simpleSpan);
+ if(nullable !== null) {
+ return new SnapshotSpan(this.snapshot, nullable);
+ }
+ return null;
+ };
+ return SnapshotSpan;
+ })();
+ Formatting.SnapshotSpan = SnapshotSpan;
+ var SnapshotPoint = (function () {
+ function SnapshotPoint(snapshot, position) {
+ this.snapshot = snapshot;
+ this.position = position;
+ }
+ SnapshotPoint.prototype.GetContainingLine = function () {
+ return this.snapshot.GetLineFromPosition(this.position);
+ };
+ SnapshotPoint.prototype.Add = function (offset) {
+ return new SnapshotPoint(this.snapshot, this.position + offset);
+ };
+ return SnapshotPoint;
+ })();
+ Formatting.SnapshotPoint = SnapshotPoint;
+ var FileAuthoringProxy = (function () {
+ function FileAuthoringProxy(scriptSyntaxAST) {
+ this.scriptSyntaxAST = scriptSyntaxAST;
+ }
+ FileAuthoringProxy.prototype.GetASTCursor = function () {
+ return new AuthorParseNodeCursor(this);
+ };
+ return FileAuthoringProxy;
+ })();
+ Formatting.FileAuthoringProxy = FileAuthoringProxy;
+ var AuthorParseNodeCursor = (function () {
+ function AuthorParseNodeCursor(fileAuthoringProxy) {
+ this.fileAuthoringProxy = fileAuthoringProxy;
+ this.logger = this.fileAuthoringProxy.scriptSyntaxAST.getLogger();
+ this.path = new TypeScript.AstPath();
+ }
+ AuthorParseNodeCursor.prototype.fixupPath = function (newPath) {
+ var temp = new TypeScript.AstPath();
+ for(var i = 0; i < newPath.count(); i++) {
+ temp.push(newPath.asts[i]);
+ if(temp.isBodyOfCase()) {
+ var fakeBlock = this.mapBodyOfCase(temp.ast());
+ var previousBody = temp.pop();
+ temp.push(fakeBlock);
+ temp.push(previousBody);
+ }
+ }
+ return temp;
+ };
+ AuthorParseNodeCursor.prototype.mapNodeType = function (path) {
+ var nodeType = path.ast().nodeType;
+ var mapList = function () {
+ if(path.isBodyOfScript() || path.isBodyOfModule() || path.isBodyOfClass() || path.isBodyOfInterface() || path.isBodyOfFor() || path.isBodyOfForIn() || path.isBodyOfWhile() || path.isBodyOfDoWhile() || path.isBodyOfTry() || path.isBodyOfCatch() || path.isBodyOfFinally() || path.isBodyOfFunction() || path.isBodyOfWith() || path.isBodyOfSwitch() || false) {
+ return AuthorParseNodeKind.apnkBlock;
+ } else {
+ return AuthorParseNodeKind.apnkList;
+ }
+ };
+ switch(nodeType) {
+ case TypeScript.NodeType.None:
+ return AuthorParseNodeKind.apnkEmptyNode;
+ case TypeScript.NodeType.Empty:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.EmptyExpr:
+ return AuthorParseNodeKind.apnkEmptyNode;
+ case TypeScript.NodeType.True:
+ return AuthorParseNodeKind.apnkTrue;
+ case TypeScript.NodeType.False:
+ return AuthorParseNodeKind.apnkFalse;
+ case TypeScript.NodeType.This:
+ return AuthorParseNodeKind.apnkThis;
+ case TypeScript.NodeType.Super:
+ return AuthorParseNodeKind.apnkThis;
+ case TypeScript.NodeType.QString:
+ return AuthorParseNodeKind.apnkStr;
+ case TypeScript.NodeType.Regex:
+ return AuthorParseNodeKind.apnkRegExp;
+ case TypeScript.NodeType.Null:
+ return AuthorParseNodeKind.apnkNull;
+ case TypeScript.NodeType.ArrayLit:
+ return AuthorParseNodeKind.apnkArray;
+ case TypeScript.NodeType.ObjectLit:
+ return AuthorParseNodeKind.apnkObject;
+ case TypeScript.NodeType.Void:
+ return AuthorParseNodeKind.apnkNull;
+ case TypeScript.NodeType.Comma:
+ return AuthorParseNodeKind.apnkComma;
+ case TypeScript.NodeType.Pos:
+ return AuthorParseNodeKind.apnkPos;
+ case TypeScript.NodeType.Neg:
+ return AuthorParseNodeKind.apnkNeg;
+ case TypeScript.NodeType.Delete:
+ return AuthorParseNodeKind.apnkDelete;
+ case TypeScript.NodeType.Await:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.In:
+ return AuthorParseNodeKind.apnkIn;
+ case TypeScript.NodeType.Dot:
+ return AuthorParseNodeKind.apnkDot;
+ case TypeScript.NodeType.From:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.Is:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.InstOf:
+ return AuthorParseNodeKind.apnkInstOf;
+ case TypeScript.NodeType.Typeof:
+ return AuthorParseNodeKind.apnkTypeof;
+ case TypeScript.NodeType.NumberLit:
+ return AuthorParseNodeKind.apnkInt;
+ case TypeScript.NodeType.Name:
+ return AuthorParseNodeKind.apnkName;
+ case TypeScript.NodeType.TypeRef:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.Index:
+ return AuthorParseNodeKind.apnkIndex;
+ case TypeScript.NodeType.Call:
+ return AuthorParseNodeKind.apnkCall;
+ case TypeScript.NodeType.New:
+ return AuthorParseNodeKind.apnkNew;
+ case TypeScript.NodeType.Asg:
+ return AuthorParseNodeKind.apnkAsg;
+ case TypeScript.NodeType.AsgAdd:
+ return AuthorParseNodeKind.apnkAsgAdd;
+ case TypeScript.NodeType.AsgSub:
+ return AuthorParseNodeKind.apnkAsgDiv;
+ case TypeScript.NodeType.AsgDiv:
+ return AuthorParseNodeKind.apnkAsgMul;
+ case TypeScript.NodeType.AsgMul:
+ return AuthorParseNodeKind.apnkAsgMul;
+ case TypeScript.NodeType.AsgMod:
+ return AuthorParseNodeKind.apnkAsgMod;
+ case TypeScript.NodeType.AsgAnd:
+ return AuthorParseNodeKind.apnkAsgAnd;
+ case TypeScript.NodeType.AsgXor:
+ return AuthorParseNodeKind.apnkAsgXor;
+ case TypeScript.NodeType.AsgOr:
+ return AuthorParseNodeKind.apnkAsgOr;
+ case TypeScript.NodeType.AsgLsh:
+ return AuthorParseNodeKind.apnkAsgLsh;
+ case TypeScript.NodeType.AsgRsh:
+ return AuthorParseNodeKind.apnkAsgRsh;
+ case TypeScript.NodeType.AsgRs2:
+ return AuthorParseNodeKind.apnkAsgRs2;
+ case TypeScript.NodeType.ConditionalExpression:
+ return AuthorParseNodeKind.apnkQmark;
+ case TypeScript.NodeType.LogOr:
+ return AuthorParseNodeKind.apnkLogOr;
+ case TypeScript.NodeType.LogAnd:
+ return AuthorParseNodeKind.apnkLogAnd;
+ case TypeScript.NodeType.Or:
+ return AuthorParseNodeKind.apnkOr;
+ case TypeScript.NodeType.Xor:
+ return AuthorParseNodeKind.apnkXor;
+ case TypeScript.NodeType.And:
+ return AuthorParseNodeKind.apnkAnd;
+ case TypeScript.NodeType.Eq:
+ return AuthorParseNodeKind.apnkEq;
+ case TypeScript.NodeType.Ne:
+ return AuthorParseNodeKind.apnkNe;
+ case TypeScript.NodeType.Eqv:
+ return AuthorParseNodeKind.apnkEqv;
+ case TypeScript.NodeType.NEqv:
+ return AuthorParseNodeKind.apnkNEqv;
+ case TypeScript.NodeType.Lt:
+ return AuthorParseNodeKind.apnkLt;
+ case TypeScript.NodeType.Le:
+ return AuthorParseNodeKind.apnkLe;
+ case TypeScript.NodeType.Gt:
+ return AuthorParseNodeKind.apnkGt;
+ case TypeScript.NodeType.Ge:
+ return AuthorParseNodeKind.apnkGe;
+ case TypeScript.NodeType.Add:
+ return AuthorParseNodeKind.apnkAdd;
+ case TypeScript.NodeType.Sub:
+ return AuthorParseNodeKind.apnkSub;
+ case TypeScript.NodeType.Mul:
+ return AuthorParseNodeKind.apnkMul;
+ case TypeScript.NodeType.Div:
+ return AuthorParseNodeKind.apnkDiv;
+ case TypeScript.NodeType.Mod:
+ return AuthorParseNodeKind.apnkMod;
+ case TypeScript.NodeType.Lsh:
+ return AuthorParseNodeKind.apnkLsh;
+ case TypeScript.NodeType.Rsh:
+ return AuthorParseNodeKind.apnkRsh;
+ case TypeScript.NodeType.Rs2:
+ return AuthorParseNodeKind.apnkRs2;
+ case TypeScript.NodeType.Not:
+ return AuthorParseNodeKind.apnkNot;
+ case TypeScript.NodeType.LogNot:
+ return AuthorParseNodeKind.apnkLogNot;
+ case TypeScript.NodeType.IncPre:
+ return AuthorParseNodeKind.apnkIncPre;
+ case TypeScript.NodeType.DecPre:
+ return AuthorParseNodeKind.apnkDecPre;
+ case TypeScript.NodeType.IncPost:
+ return AuthorParseNodeKind.apnkIncPost;
+ case TypeScript.NodeType.DecPost:
+ return AuthorParseNodeKind.apnkDecPost;
+ case TypeScript.NodeType.TypeAssertion:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.FuncDecl:
+ return AuthorParseNodeKind.apnkFncDecl;
+ case TypeScript.NodeType.Member:
+ return AuthorParseNodeKind.apnkMember;
+ case TypeScript.NodeType.VarDecl:
+ return AuthorParseNodeKind.apnkVarDecl;
+ case TypeScript.NodeType.ArgDecl:
+ return AuthorParseNodeKind.apnkVarDecl;
+ case TypeScript.NodeType.Return:
+ return AuthorParseNodeKind.apnkReturn;
+ case TypeScript.NodeType.Break:
+ return AuthorParseNodeKind.apnkBreak;
+ case TypeScript.NodeType.Continue:
+ return AuthorParseNodeKind.apnkContinue;
+ case TypeScript.NodeType.Throw:
+ return AuthorParseNodeKind.apnkThrow;
+ case TypeScript.NodeType.For:
+ return AuthorParseNodeKind.apnkFor;
+ case TypeScript.NodeType.ForIn:
+ return AuthorParseNodeKind.apnkForIn;
+ case TypeScript.NodeType.If:
+ return AuthorParseNodeKind.apnkIf;
+ case TypeScript.NodeType.While:
+ return AuthorParseNodeKind.apnkWhile;
+ case TypeScript.NodeType.DoWhile:
+ return AuthorParseNodeKind.apnkDoWhile;
+ case TypeScript.NodeType.Block:
+ return (path.ast()).isStatementBlock ? AuthorParseNodeKind.apnkBlock : AuthorParseNodeKind.apnkVarDeclList;
+ case TypeScript.NodeType.Case:
+ return AuthorParseNodeKind.apnkCase;
+ case TypeScript.NodeType.Switch:
+ return AuthorParseNodeKind.apnkSwitch;
+ case TypeScript.NodeType.Try:
+ return AuthorParseNodeKind.apnkTry;
+ case TypeScript.NodeType.TryCatch:
+ return AuthorParseNodeKind.apnkTryCatch;
+ case TypeScript.NodeType.TryFinally:
+ return AuthorParseNodeKind.apnkTryFinally;
+ case TypeScript.NodeType.Finally:
+ return AuthorParseNodeKind.apnkFinally;
+ case TypeScript.NodeType.Catch:
+ return AuthorParseNodeKind.apnkCatch;
+ case TypeScript.NodeType.List:
+ return mapList();
+ case TypeScript.NodeType.Script:
+ return AuthorParseNodeKind.apnkProg;
+ case TypeScript.NodeType.ClassDeclaration:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.InterfaceDeclaration:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.ModuleDeclaration:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.ImportDeclaration:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.With:
+ return AuthorParseNodeKind.apnkWith;
+ case TypeScript.NodeType.Label:
+ return AuthorParseNodeKind.apnkLabel;
+ case TypeScript.NodeType.LabeledStatement:
+ return AuthorParseNodeKind.apnkLabel;
+ case TypeScript.NodeType.EBStart:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.GotoEB:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.EndCode:
+ return AuthorParseNodeKind.apnkEndCode;
+ case TypeScript.NodeType.Error:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.Comment:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.Debugger:
+ return AuthorParseNodeKind.apnkDebugger;
+ default:
+ throw new Error("Invalid node kind: " + nodeType);
+ }
+ };
+ AuthorParseNodeCursor.prototype.mapNodeFlags = function (path) {
+ var result = AuthorParseNodeFlags.apnfNone;
+ if(path.isSynthesizedBlock()) {
+ result = result | AuthorParseNodeFlags.apnfSyntheticNode;
+ }
+ return result;
+ };
+ AuthorParseNodeCursor.prototype.getDetails = function (path) {
+ var ast = path.ast();
+ var result = new AuthorParseNodeDetails();
+ if(path.isListOfObjectLit()) {
+ if(!path.parent().isParenthesized) {
+ Formatting.Debug.Assert(path.parent().minChar == path.ast().minChar, "Assumption about AST minChar position is not verified");
+ Formatting.Debug.Assert(path.parent().limChar == path.ast().limChar, "Assumption about AST limChar position is not verified");
+ }
+ result.StartOffset = ast.minChar + 1;
+ result.EndOffset = ast.limChar - 1;
+ } else {
+ result.StartOffset = ast.minChar;
+ result.EndOffset = ast.limChar;
+ }
+ result.Flags = this.mapNodeFlags(path);
+ result.Kind = this.mapNodeType(path);
+ result.nodeType = ast.nodeType;
+ result.ast = ast;
+ return result;
+ };
+ AuthorParseNodeCursor.prototype.getEdgeLabel = function (path) {
+ if(path.isBodyOfScript() || path.isBodyOfModule() || path.isBodyOfClass() || path.isBodyOfInterface() || path.isBodyOfFunction() || path.isBodyOfFor() || path.isBodyOfForIn() || path.isBodyOfWhile() || path.isBodyOfDoWhile() || path.isBodyOfWith() || path.isBodyOfSwitch() || this.isBodyOfCase(path) || path.isBodyOfTry() || path.isBodyOfCatch() || path.isBodyOfFinally()) {
+ return AuthorParseNodeEdge.apneBody;
+ }
+ if(path.isThenOfIf()) {
+ return AuthorParseNodeEdge.apneThen;
+ }
+ if(path.isElseOfIf()) {
+ return AuthorParseNodeEdge.apneElse;
+ }
+ if(path.isBodyOfBlock() || this.isBodyOfBlock(path)) {
+ return AuthorParseNodeEdge.apneBlockBody;
+ }
+ if(path.isDefaultCaseOfSwitch()) {
+ return AuthorParseNodeEdge.apneDefaultCase;
+ }
+ if(path.isCaseOfSwitch()) {
+ return AuthorParseNodeEdge.apneCase;
+ }
+ if(path.isListOfObjectLit()) {
+ return AuthorParseNodeEdge.apneMembers;
+ }
+ if(path.isListOfArrayLit()) {
+ return AuthorParseNodeEdge.apneElements;
+ }
+ if(path.isMemberOfMember()) {
+ return AuthorParseNodeEdge.apneMember;
+ }
+ if(path.isTargetOfMember()) {
+ return AuthorParseNodeEdge.apneTarget;
+ }
+ if(path.isArgumentOfFunction()) {
+ return AuthorParseNodeEdge.apneArgument;
+ }
+ if(path.isItemOfList()) {
+ return AuthorParseNodeEdge.apneListItem;
+ }
+ return AuthorParseNodeEdge.apneNone;
+ };
+ AuthorParseNodeCursor.prototype.getEmptyNodeDetails = function () {
+ var result = new AuthorParseNodeDetails();
+ result.StartOffset = 0;
+ result.EndOffset = 0;
+ result.Flags = AuthorParseNodeFlags.apnfNone;
+ result.Kind = AuthorParseNodeKind.apnkEmptyNode;
+ result.nodeType = TypeScript.NodeType.Empty;
+ result.ast = null;
+ return result;
+ };
+ AuthorParseNodeCursor.prototype.getAstPath = function (position, options) {
+ if (typeof options === "undefined") { options = TypeScript.GetAstPathOptions.Default; }
+ var path = this.fileAuthoringProxy.scriptSyntaxAST.getAstPathToPosition(position, options);
+ while(path.count() >= 1 && this.skipNode(path)) {
+ path.up();
+ }
+ return path;
+ };
+ AuthorParseNodeCursor.prototype.moveToParent = function (path) {
+ while(path.count() >= 1) {
+ path.up();
+ if(!this.skipNode(path)) {
+ break;
+ }
+ }
+ };
+ AuthorParseNodeCursor.prototype.getAuthorParseNodeDetails = function (path) {
+ if(path.count() === 0) {
+ return this.getEmptyNodeDetails();
+ } else {
+ return this.getDetails(path);
+ }
+ };
+ AuthorParseNodeCursor.prototype.Current = function () {
+ return this.getAuthorParseNodeDetails(this.path);
+ };
+ AuthorParseNodeCursor.prototype.Parent = function () {
+ var temp = this.path.clone();
+ this.moveToParent(temp);
+ return this.getAuthorParseNodeDetails(temp);
+ };
+ AuthorParseNodeCursor.prototype.MoveToChild = function (edgeLabel, index) {
+ var _this = this;
+ var pushIfNotNull = function (node) {
+ if(node != null) {
+ _this.path.push(node);
+ return _this.getAuthorParseNodeDetails(_this.path);
+ } else {
+ return _this.getEmptyNodeDetails();
+ }
+ };
+ if(this.path.count() >= 1) {
+ var ast = this.path.ast();
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.ArrayLit:
+ {
+ switch(edgeLabel) {
+ case AuthorParseNodeEdge.apneElements:
+ return pushIfNotNull((ast).operand);
+ }
+ }
+ break;
+ }
+ }
+ var empty = new TypeScript.AST(TypeScript.NodeType.Empty);
+ this.path.push(empty);
+ return this.getAuthorParseNodeDetails(this.path);
+ };
+ AuthorParseNodeCursor.prototype.MoveUp = function () {
+ this.moveToParent(this.path);
+ return this.getAuthorParseNodeDetails(this.path);
+ };
+ AuthorParseNodeCursor.prototype.SeekToOffset = function (offset, excludeEndOffset) {
+ var newPath = this.getAstPath(offset, excludeEndOffset ? TypeScript.GetAstPathOptions.Default : TypeScript.GetAstPathOptions.EdgeInclusive);
+ this.path = this.fixupPath(newPath);
+ if(this.path.count() == 0) {
+ return null;
+ }
+ return this.getDetails(this.path);
+ };
+ AuthorParseNodeCursor.prototype.MoveToEnclosingNode = function (startOffset, endOffset) {
+ if(startOffset > endOffset) {
+ throw new Error("Invalid offsets");
+ }
+ var start = this.getAstPath(startOffset);
+ var end = this.getAstPath(endOffset - 1);
+ if(start.count() == 0 || end.count() == 0) {
+ throw new Error("No nodes enclosing span");
+ }
+ var startIndex = 0;
+ var endIndex = 0;
+ while(startIndex < start.count() && endIndex < end.count()) {
+ if(start.get(startIndex) !== end.get(endIndex)) {
+ break;
+ }
+ startIndex++;
+ endIndex++;
+ }
+ start.top = startIndex - 1;
+ while(this.skipNode(start)) {
+ start.up();
+ }
+ this.path = this.fixupPath(start);
+ return this.getDetails(this.path);
+ };
+ AuthorParseNodeCursor.prototype.skipNode = function (path) {
+ return path.isBodyOfSwitch() || path.isTopLevelImplicitModule() || path.isBodyOfTopLevelImplicitModule() || (path.isBodyOfBlock() && path.isSingleStatementList()) || (path.isBodyOfCase() && path.isSingleStatementList()) || (path.isArgumentListOfFunction());
+ };
+ AuthorParseNodeCursor.prototype.mapAstNode = function (path, depth) {
+ if(!TypeScript.isValidAstNode(path.ast())) {
+ return null;
+ }
+ if(this.skipNode(path)) {
+ return null;
+ }
+ var result = new AuthorParseNode();
+ result.Details = this.getDetails(path);
+ result.Level = depth;
+ result.Label = 0;
+ result.Name = 0;
+ result.EdgeLabel = this.getEdgeLabel(path);
+ return result;
+ };
+ AuthorParseNodeCursor.prototype.isBodyOfBlock = function (path) {
+ var result = false;
+ if(path.count() >= 2) {
+ if(path.ast().nodeType == TypeScript.NodeType.List && !path.isSingleStatementList() && path.isBodyOfCase()) {
+ result = true;
+ }
+ path.up();
+ if(path.ast().nodeType == TypeScript.NodeType.List && path.isSingleStatementList() && path.isBodyOfCase()) {
+ result = true;
+ }
+ path.down();
+ }
+ return result;
+ };
+ AuthorParseNodeCursor.prototype.isBodyOfCase = function (path) {
+ var asts = path.asts;
+ var top = path.top;
+ return path.count() >= 2 && asts[top - 1].nodeType === TypeScript.NodeType.Case && asts[top - 0].nodeType === TypeScript.NodeType.Block && (asts[top - 1]).body == (asts[top - 0]).statements;
+ };
+ AuthorParseNodeCursor.prototype.mapBodyOfCase = function (body) {
+ var fakeBlock = new TypeScript.Block(body, false);
+ fakeBlock.minChar = body.minChar;
+ fakeBlock.limChar = body.limChar;
+ return fakeBlock;
+ };
+ AuthorParseNodeCursor.prototype.GetSubTree = function (depth) {
+ var _this = this;
+ if(this.path.count() == 0) {
+ return new AuthorParseNodeSet([]);
+ }
+ var context = {
+ path: new TypeScript.AstPath(),
+ nodes: [],
+ curDepth: 0,
+ curDepths: []
+ };
+ var pre = function (cur, parent, walker) {
+ context.curDepths.push(context.curDepth);
+ context.path.push(cur);
+ if(context.path.isBodyOfCase()) {
+ var fakeBlock = _this.mapBodyOfCase(cur);
+ var previousBody = context.path.pop();
+ context.path.push(fakeBlock);
+ context.nodes.push(_this.mapAstNode(context.path, context.curDepth));
+ context.curDepth++;
+ context.path.pop();
+ context.path.push(previousBody);
+ }
+ var node = _this.mapAstNode(context.path, context.curDepth);
+ if(node !== null) {
+ context.nodes.push(node);
+ context.curDepth++;
+ }
+ walker.options.goChildren = (depth < 0 || context.curDepth <= depth);
+ return cur;
+ };
+ var post = function (cur, parent, walker) {
+ context.curDepth = context.curDepths.pop();
+ context.path.pop();
+ return cur;
+ };
+ TypeScript.getAstWalkerFactory().walk(this.path.ast(), pre, post);
+ if(this.logger.information()) {
+ this.logger.log("getSubTree(" + depth + ")");
+ for(var i = 0; i < context.nodes.length; i++) {
+ var authorNode = context.nodes[i];
+ var text = authorNode.Level + ": " + (AuthorParseNodeKind)._map[authorNode.Details.Kind] + " - " + (TypeScript.NodeType)._map[authorNode.Details.nodeType] + "(" + (AuthorParseNodeEdge)._map[authorNode.EdgeLabel] + ")" + "(" + authorNode.Details.StartOffset + "," + authorNode.Details.EndOffset + ")" + " -- F:(" + authorNode.Details.Flags + ")";
+ this.logger.log(text);
+ }
+ }
+ return new AuthorParseNodeSet(context.nodes);
+ };
+ AuthorParseNodeCursor.prototype.GetNodeProperty = function (nodeProperty) {
+ if(this.path.count() == 0) {
+ return 0;
+ }
+ var authorNode = this.mapAstNode(this.path, 0);
+ if(authorNode.Details.ast === null) {
+ return 0;
+ }
+ switch(authorNode.Details.ast.nodeType) {
+ case TypeScript.NodeType.FuncDecl:
+ {
+ var funcDecl = (authorNode.Details.ast);
+ var bod = funcDecl.bod;
+ switch(nodeProperty) {
+ case AuthorParseNodeProperty.apnpFunctionKeywordMin:
+ return funcDecl.minChar;
+ case AuthorParseNodeProperty.apnpLCurlyMin:
+ if(bod !== null && bod.minChar > 0) {
+ return bod.minChar;
+ } else {
+ return 0;
+ }
+ case AuthorParseNodeProperty.apnpRCurlyMin:
+ if(bod !== null && bod.limChar > 0) {
+ return bod.limChar - 1;
+ } else {
+ return 0;
+ }
+ case AuthorParseNodeProperty.apnpRParenMin:
+ if(funcDecl.arguments != null && funcDecl.arguments.limChar > 0) {
+ return funcDecl.arguments.limChar - 1;
+ }
+ }
+ }
+ break;
+ case TypeScript.NodeType.ClassDeclaration:
+ {
+ var classDecl = authorNode.Details.ast;
+ var bod = classDecl.members;
+ switch(nodeProperty) {
+ case AuthorParseNodeProperty.apnpLCurlyMin:
+ if(bod !== null) {
+ return bod.minChar;
+ } else {
+ return 0;
+ }
+ case AuthorParseNodeProperty.apnpRCurlyMin:
+ if(bod !== null) {
+ return bod.limChar - 1;
+ } else {
+ return 0;
+ }
+ }
+ }
+ break;
+ }
+ if(this.logger.warning()) {
+ this.logger.log("NYI:GetNodeProperty " + "(nodeType=" + (TypeScript.NodeType)._map[authorNode.Details.ast.nodeType] + ", " + "propperty= " + (AuthorParseNodeProperty)._map[nodeProperty] + ")");
+ }
+ return 0;
+ };
+ AuthorParseNodeCursor.prototype.GetEdgeLabel = function () {
+ return this.mapAstNode(this.path, 0).EdgeLabel;
+ };
+ return AuthorParseNodeCursor;
+ })();
+ Formatting.AuthorParseNodeCursor = AuthorParseNodeCursor;
+ var TextSnapshot = (function () {
+ function TextSnapshot(script, sourceText) {
+ this.script = script;
+ this.sourceText = sourceText;
+ this.lines = [];
+ }
+ TextSnapshot.prototype.GetText = function (span) {
+ return this.sourceText.getText(span.start(), span.end());
+ };
+ TextSnapshot.prototype.GetLineNumberFromPosition = function (position) {
+ var lineNumber = TypeScript.getLineNumberFromPosition(this.script.locationInfo.lineMap, position);
+ return lineNumber - 1;
+ };
+ TextSnapshot.prototype.GetLineFromPosition = function (position) {
+ var lineNumber = this.GetLineNumberFromPosition(position);
+ return this.GetLineFromLineNumber(lineNumber);
+ };
+ TextSnapshot.prototype.GetLineFromLineNumber = function (lineNumber) {
+ var line = this.lines[lineNumber];
+ if(line === undefined) {
+ line = this.GetLineFromLineNumberWorker(lineNumber);
+ this.lines[lineNumber] = line;
+ }
+ return line;
+ };
+ TextSnapshot.prototype.GetLineFromLineNumberWorker = function (lineNumber) {
+ var lineMap = this.script.locationInfo.lineMap;
+ var lineMapIndex = lineNumber + 1;
+ if(lineMapIndex < 1 || lineMapIndex >= lineMap.length) {
+ throw new Error("invalid line number (" + lineMapIndex + ")");
+ }
+ var start = lineMap[lineMapIndex];
+ var end;
+ var endIncludingLineBreak;
+ var lineBreak = "";
+ if(lineMapIndex == lineMap.length) {
+ end = endIncludingLineBreak = this.sourceText.getLength();
+ } else {
+ endIncludingLineBreak = (lineMapIndex >= lineMap.length - 1 ? this.sourceText.getLength() : this.script.locationInfo.lineMap[lineMapIndex + 1]);
+ for(var p = endIncludingLineBreak - 1; p >= start; p--) {
+ var c = this.sourceText.getText(p, p + 1);
+ if(c != "\r" && c != "\n") {
+ break;
+ }
+ }
+ end = p + 1;
+ lineBreak = this.sourceText.getText(end, endIncludingLineBreak);
+ }
+ var result = new TextSnapshotLine(this, lineNumber, start, end, lineBreak);
+ return result;
+ };
+ return TextSnapshot;
+ })();
+ Formatting.TextSnapshot = TextSnapshot;
+ var TextSnapshotLine = (function () {
+ function TextSnapshotLine(_snapshot, _lineNumber, _start, _end, _lineBreak) {
+ this._snapshot = _snapshot;
+ this._lineNumber = _lineNumber;
+ this._start = _start;
+ this._end = _end;
+ this._lineBreak = _lineBreak;
+ }
+ TextSnapshotLine.prototype.snapshot = function () {
+ return this._snapshot;
+ };
+ TextSnapshotLine.prototype.start = function () {
+ return new SnapshotPoint(this._snapshot, this._start);
+ };
+ TextSnapshotLine.prototype.startPosition = function () {
+ return this._start;
+ };
+ TextSnapshotLine.prototype.end = function () {
+ return new SnapshotPoint(this._snapshot, this._end);
+ };
+ TextSnapshotLine.prototype.endPosition = function () {
+ return this._end;
+ };
+ TextSnapshotLine.prototype.endIncludingLineBreak = function () {
+ return new SnapshotPoint(this._snapshot, this._end + this._lineBreak.length);
+ };
+ TextSnapshotLine.prototype.endIncludingLineBreakPosition = function () {
+ return this._end + this._lineBreak.length;
+ };
+ TextSnapshotLine.prototype.length = function () {
+ return this._end - this._start;
+ };
+ TextSnapshotLine.prototype.lineNumber = function () {
+ return this._lineNumber;
+ };
+ TextSnapshotLine.prototype.getText = function () {
+ return this._snapshot.GetText(Span.FromBounds(this._start, this._end));
+ };
+ return TextSnapshotLine;
+ })();
+ Formatting.TextSnapshotLine = TextSnapshotLine;
+ var Span = (function () {
+ function Span(_start, _length) {
+ this._start = _start;
+ this._length = _length;
+ if(this._start < 0) {
+ throw new Error("Invalid start value");
+ }
+ if(this._length < 0) {
+ throw new Error("Invalid length value");
+ }
+ }
+ Span.prototype.start = function () {
+ return this._start;
+ };
+ Span.prototype.end = function () {
+ return this._start + this._length;
+ };
+ Span.prototype.length = function () {
+ return this._length;
+ };
+ Span.prototype.Intersection = function (span) {
+ var start = Math.Max(this.start(), span.start());
+ var end = Math.Min(this.end(), span.end());
+ if(start <= end) {
+ return Span.FromBounds(start, end);
+ }
+ return null;
+ };
+ Span.prototype.OverlapsWith = function (span) {
+ var num = Math.Max(this.start(), span.start());
+ var num2 = Math.Min(this.end(), span.end());
+ return (num < num2);
+ };
+ Span.prototype.Contains = function (span) {
+ return ((span.start() >= this.start()) && (span.end() <= this.end()));
+ };
+ Span.FromBounds = function FromBounds(start, end) {
+ return new Span(start, end - start);
+ };
+ return Span;
+ })();
+ Formatting.Span = Span;
+ var ListEnumerator = (function () {
+ function ListEnumerator(list) {
+ this.list = list;
+ this.index = -1;
+ }
+ ListEnumerator.prototype.MoveNext = function () {
+ if(this.index < this.list.count() - 1) {
+ this.index++;
+ return true;
+ }
+ return false;
+ };
+ ListEnumerator.prototype.Current = function () {
+ return this.list.get(this.index);
+ };
+ return ListEnumerator;
+ })();
+ Formatting.ListEnumerator = ListEnumerator;
+ var List = (function () {
+ function List() {
+ this.items = List.empty;
+ }
+ List.empty = [];
+ List.prototype.copyOnWrite = function () {
+ if(this.items === List.empty) {
+ this.items = [];
+ }
+ };
+ List.prototype.count = function () {
+ return this.items.length;
+ };
+ List.prototype.get = function (index) {
+ var result = this.items[index];
+ if(result === undefined) {
+ throw new Error("Invalid list index " + index + " (valid range is 0 to " + (this.items.length - 1) + ")");
+ }
+ return result;
+ };
+ List.prototype.add = function (item) {
+ if(item === undefined) {
+ throw new Error("Cannot add an undefined value in a list");
+ }
+ this.copyOnWrite();
+ this.items.push(item);
+ };
+ List.prototype.addAll = function (range) {
+ var _this = this;
+ range.forEach(function (item) {
+ _this.add(item);
+ });
+ };
+ List.prototype.insert = function (index, item) {
+ if(item === undefined) {
+ throw new Error("Cannot add an undefined value in a list");
+ }
+ if(index < 0 || index > this.items.length) {
+ throw new Error("Invalid index when inserting into array" + " (valid range is 0 to " + this.items.length + ")");
+ }
+ this.copyOnWrite();
+ this.items.splice(index, 0, item);
+ };
+ List.prototype.contains = function (item) {
+ var found = false;
+ this.foreach(function (i) {
+ if(i === item) {
+ found = true;
+ }
+ });
+ return found;
+ };
+ List.prototype.foreach = function (action) {
+ var list = this;
+ for(var i = 0, len = list.count(); i < len; i++) {
+ action(list.get(i));
+ }
+ };
+ List.prototype.GetEnumerator = function () {
+ return new ListEnumerator(this);
+ };
+ List.prototype.Where = function (pred) {
+ var result = new List();
+ this.foreach(function (item) {
+ if(pred(item)) {
+ result.add(item);
+ }
+ });
+ return result;
+ };
+ return List;
+ })();
+ Formatting.List = List;
+ var List_TokenSpan = (function (_super) {
+ __extends(List_TokenSpan, _super);
+ function List_TokenSpan() {
+ _super.apply(this, arguments);
+
+ }
+ List_TokenSpan.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_TokenSpan.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_TokenSpan;
+ })(List);
+ Formatting.List_TokenSpan = List_TokenSpan;
+ var List_AuthorTokenKind = (function (_super) {
+ __extends(List_AuthorTokenKind, _super);
+ function List_AuthorTokenKind() {
+ _super.apply(this, arguments);
+
+ }
+ List_AuthorTokenKind.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_AuthorTokenKind.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_AuthorTokenKind;
+ })(List);
+ Formatting.List_AuthorTokenKind = List_AuthorTokenKind;
+ var List_IndentationInfo = (function (_super) {
+ __extends(List_IndentationInfo, _super);
+ function List_IndentationInfo() {
+ _super.apply(this, arguments);
+
+ }
+ List_IndentationInfo.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_IndentationInfo.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_IndentationInfo;
+ })(List);
+ Formatting.List_IndentationInfo = List_IndentationInfo;
+ var List_IndentationEditInfo = (function (_super) {
+ __extends(List_IndentationEditInfo, _super);
+ function List_IndentationEditInfo() {
+ _super.apply(this, arguments);
+
+ }
+ List_IndentationEditInfo.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_IndentationEditInfo.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_IndentationEditInfo;
+ })(List);
+ Formatting.List_IndentationEditInfo = List_IndentationEditInfo;
+ var List_ParseNode = (function (_super) {
+ __extends(List_ParseNode, _super);
+ function List_ParseNode() {
+ _super.apply(this, arguments);
+
+ }
+ List_ParseNode.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_ParseNode.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_ParseNode;
+ })(List);
+ Formatting.List_ParseNode = List_ParseNode;
+ var List_TextEditInfo = (function (_super) {
+ __extends(List_TextEditInfo, _super);
+ function List_TextEditInfo(item) {
+ if (typeof item === "undefined") { item = null; }
+ _super.call(this);
+ if(item != null) {
+ this.add(item);
+ }
+ }
+ List_TextEditInfo.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_TextEditInfo.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_TextEditInfo;
+ })(List);
+ Formatting.List_TextEditInfo = List_TextEditInfo;
+ var List_Rule = (function (_super) {
+ __extends(List_Rule, _super);
+ function List_Rule() {
+ _super.apply(this, arguments);
+
+ }
+ List_Rule.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_Rule.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ List_Rule.prototype.Add = function (item) {
+ _super.prototype.add.call(this, item);
+ };
+ List_Rule.prototype.AddRange = function (items) {
+ var _this = this;
+ items.forEach(function (item) {
+ _this.Add(item);
+ });
+ };
+ return List_Rule;
+ })(List);
+ Formatting.List_Rule = List_Rule;
+ var List_ITextSnapshotLine = (function (_super) {
+ __extends(List_ITextSnapshotLine, _super);
+ function List_ITextSnapshotLine() {
+ _super.apply(this, arguments);
+
+ }
+ List_ITextSnapshotLine.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_ITextSnapshotLine.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_ITextSnapshotLine;
+ })(List);
+ Formatting.List_ITextSnapshotLine = List_ITextSnapshotLine;
+ var Stack = (function () {
+ function Stack() {
+ this.items = [];
+ }
+ Stack.prototype.Count = function () {
+ return this.items.length;
+ };
+ Stack.prototype.Push = function (item) {
+ if(item === undefined) {
+ throw new Error("Cannot add an undefined value in a list");
+ }
+ this.items.push(item);
+ };
+ Stack.prototype.Pop = function () {
+ if(this.items.length === 0) {
+ throw new Error("Cannot pop from an empty stack");
+ }
+ return this.items.pop();
+ };
+ return Stack;
+ })();
+ Formatting.Stack = Stack;
+ var Stack_ParseNode = (function (_super) {
+ __extends(Stack_ParseNode, _super);
+ function Stack_ParseNode() {
+ _super.apply(this, arguments);
+
+ }
+ Stack_ParseNode.prototype.Pop = function () {
+ return _super.prototype.Pop.call(this);
+ };
+ return Stack_ParseNode;
+ })(Stack);
+ Formatting.Stack_ParseNode = Stack_ParseNode;
+ function BinarySearch(list, searchValue, comparer) {
+ var low = 0;
+ var high = list.count();
+ while(low < high) {
+ var median = (low + high) >> 1;
+ var compareResult = comparer(searchValue, list.get(median));
+ if(compareResult > 0) {
+ low = median + 1;
+ } else {
+ high = median;
+ }
+ }
+ Debug.Assert(low >= 0 && low <= list.count(), "Incorrect implementation of BinarySearch");
+ if(low == list.count() || comparer(searchValue, list.get(low)) != 0) {
+ return ~low;
+ }
+ return low;
+ }
+ Formatting.BinarySearch = BinarySearch;
+ function FirstOrDefault(list, pred) {
+ for(var i = 0, len = list.count(); i < len; i++) {
+ if(pred(list.get(i))) {
+ return list.get(i);
+ }
+ }
+ return null;
+ }
+ Formatting.FirstOrDefault = FirstOrDefault;
+ function LastOrDefault(list, pred) {
+ for(var len = list.count(), i = len - 1; i >= 0; i--) {
+ if(pred(list.get(i))) {
+ return list.get(i);
+ }
+ }
+ return null;
+ }
+ Formatting.LastOrDefault = LastOrDefault;
+ var AuthorParseNode = (function () {
+ function AuthorParseNode() {
+ }
+ return AuthorParseNode;
+ })();
+ Formatting.AuthorParseNode = AuthorParseNode;
+ var AuthorParseNodeDetails = (function () {
+ function AuthorParseNodeDetails() {
+ }
+ AuthorParseNodeDetails.prototype.Equals = function (other) {
+ if(other == null) {
+ return false;
+ }
+ return this.Kind == other.Kind && this.nodeType == other.nodeType && this.StartOffset == other.StartOffset && this.EndOffset == other.EndOffset && this.Flags == other.Flags;
+ };
+ return AuthorParseNodeDetails;
+ })();
+ Formatting.AuthorParseNodeDetails = AuthorParseNodeDetails;
+ (function (AuthorParseNodeFlags) {
+ AuthorParseNodeFlags._map = [];
+ AuthorParseNodeFlags.apnfNone = 0x0000;
+ AuthorParseNodeFlags.apnfSyntheticNode = 0x0100;
+ })(Formatting.AuthorParseNodeFlags || (Formatting.AuthorParseNodeFlags = {}));
+ var AuthorParseNodeFlags = Formatting.AuthorParseNodeFlags;
+ (function (AuthorParseNodeKind) {
+ AuthorParseNodeKind._map = [];
+ AuthorParseNodeKind._map[0] = "apnkEmptyNode";
+ AuthorParseNodeKind.apnkEmptyNode = 0;
+ AuthorParseNodeKind._map[1] = "apnkNone";
+ AuthorParseNodeKind.apnkNone = 1;
+ AuthorParseNodeKind._map[2] = "apnkName";
+ AuthorParseNodeKind.apnkName = 2;
+ AuthorParseNodeKind._map[3] = "apnkInt";
+ AuthorParseNodeKind.apnkInt = 3;
+ AuthorParseNodeKind._map[4] = "apnkFlt";
+ AuthorParseNodeKind.apnkFlt = 4;
+ AuthorParseNodeKind._map[5] = "apnkStr";
+ AuthorParseNodeKind.apnkStr = 5;
+ AuthorParseNodeKind._map[6] = "apnkRegExp";
+ AuthorParseNodeKind.apnkRegExp = 6;
+ AuthorParseNodeKind._map[7] = "apnkThis";
+ AuthorParseNodeKind.apnkThis = 7;
+ AuthorParseNodeKind._map[8] = "apnkNull";
+ AuthorParseNodeKind.apnkNull = 8;
+ AuthorParseNodeKind._map[9] = "apnkFalse";
+ AuthorParseNodeKind.apnkFalse = 9;
+ AuthorParseNodeKind._map[10] = "apnkTrue";
+ AuthorParseNodeKind.apnkTrue = 10;
+ AuthorParseNodeKind._map[11] = "apnkEmpty";
+ AuthorParseNodeKind.apnkEmpty = 11;
+ AuthorParseNodeKind._map[12] = "apnkLdFncSlot";
+ AuthorParseNodeKind.apnkLdFncSlot = 12;
+ AuthorParseNodeKind._map[13] = "apnkArgRef";
+ AuthorParseNodeKind.apnkArgRef = 13;
+ AuthorParseNodeKind._map[14] = "apnkHelperCall3";
+ AuthorParseNodeKind.apnkHelperCall3 = 14;
+ AuthorParseNodeKind._map[15] = "apnkNot";
+ AuthorParseNodeKind.apnkNot = 15;
+ AuthorParseNodeKind._map[16] = "apnkNeg";
+ AuthorParseNodeKind.apnkNeg = 16;
+ AuthorParseNodeKind._map[17] = "apnkPos";
+ AuthorParseNodeKind.apnkPos = 17;
+ AuthorParseNodeKind._map[18] = "apnkLogNot";
+ AuthorParseNodeKind.apnkLogNot = 18;
+ AuthorParseNodeKind._map[19] = "apnkIncPost";
+ AuthorParseNodeKind.apnkIncPost = 19;
+ AuthorParseNodeKind._map[20] = "apnkDecPost";
+ AuthorParseNodeKind.apnkDecPost = 20;
+ AuthorParseNodeKind._map[21] = "apnkIncPre";
+ AuthorParseNodeKind.apnkIncPre = 21;
+ AuthorParseNodeKind._map[22] = "apnkDecPre";
+ AuthorParseNodeKind.apnkDecPre = 22;
+ AuthorParseNodeKind._map[23] = "apnkTypeof";
+ AuthorParseNodeKind.apnkTypeof = 23;
+ AuthorParseNodeKind._map[24] = "apnkVoid";
+ AuthorParseNodeKind.apnkVoid = 24;
+ AuthorParseNodeKind._map[25] = "apnkDelete";
+ AuthorParseNodeKind.apnkDelete = 25;
+ AuthorParseNodeKind._map[26] = "apnkArray";
+ AuthorParseNodeKind.apnkArray = 26;
+ AuthorParseNodeKind._map[27] = "apnkObject";
+ AuthorParseNodeKind.apnkObject = 27;
+ AuthorParseNodeKind._map[28] = "apnkTempRef";
+ AuthorParseNodeKind.apnkTempRef = 28;
+ AuthorParseNodeKind._map[29] = "apnkStFncSlot";
+ AuthorParseNodeKind.apnkStFncSlot = 29;
+ AuthorParseNodeKind._map[30] = "apnkAdd";
+ AuthorParseNodeKind.apnkAdd = 30;
+ AuthorParseNodeKind._map[31] = "apnkSub";
+ AuthorParseNodeKind.apnkSub = 31;
+ AuthorParseNodeKind._map[32] = "apnkMul";
+ AuthorParseNodeKind.apnkMul = 32;
+ AuthorParseNodeKind._map[33] = "apnkDiv";
+ AuthorParseNodeKind.apnkDiv = 33;
+ AuthorParseNodeKind._map[34] = "apnkMod";
+ AuthorParseNodeKind.apnkMod = 34;
+ AuthorParseNodeKind._map[35] = "apnkOr";
+ AuthorParseNodeKind.apnkOr = 35;
+ AuthorParseNodeKind._map[36] = "apnkXor";
+ AuthorParseNodeKind.apnkXor = 36;
+ AuthorParseNodeKind._map[37] = "apnkAnd";
+ AuthorParseNodeKind.apnkAnd = 37;
+ AuthorParseNodeKind._map[38] = "apnkEq";
+ AuthorParseNodeKind.apnkEq = 38;
+ AuthorParseNodeKind._map[39] = "apnkNe";
+ AuthorParseNodeKind.apnkNe = 39;
+ AuthorParseNodeKind._map[40] = "apnkLt";
+ AuthorParseNodeKind.apnkLt = 40;
+ AuthorParseNodeKind._map[41] = "apnkLe";
+ AuthorParseNodeKind.apnkLe = 41;
+ AuthorParseNodeKind._map[42] = "apnkGe";
+ AuthorParseNodeKind.apnkGe = 42;
+ AuthorParseNodeKind._map[43] = "apnkGt";
+ AuthorParseNodeKind.apnkGt = 43;
+ AuthorParseNodeKind._map[44] = "apnkCall";
+ AuthorParseNodeKind.apnkCall = 44;
+ AuthorParseNodeKind._map[45] = "apnkDot";
+ AuthorParseNodeKind.apnkDot = 45;
+ AuthorParseNodeKind._map[46] = "apnkAsg";
+ AuthorParseNodeKind.apnkAsg = 46;
+ AuthorParseNodeKind._map[47] = "apnkInstOf";
+ AuthorParseNodeKind.apnkInstOf = 47;
+ AuthorParseNodeKind._map[48] = "apnkIn";
+ AuthorParseNodeKind.apnkIn = 48;
+ AuthorParseNodeKind._map[49] = "apnkEqv";
+ AuthorParseNodeKind.apnkEqv = 49;
+ AuthorParseNodeKind._map[50] = "apnkNEqv";
+ AuthorParseNodeKind.apnkNEqv = 50;
+ AuthorParseNodeKind._map[51] = "apnkComma";
+ AuthorParseNodeKind.apnkComma = 51;
+ AuthorParseNodeKind._map[52] = "apnkLogOr";
+ AuthorParseNodeKind.apnkLogOr = 52;
+ AuthorParseNodeKind._map[53] = "apnkLogAnd";
+ AuthorParseNodeKind.apnkLogAnd = 53;
+ AuthorParseNodeKind._map[54] = "apnkLsh";
+ AuthorParseNodeKind.apnkLsh = 54;
+ AuthorParseNodeKind._map[55] = "apnkRsh";
+ AuthorParseNodeKind.apnkRsh = 55;
+ AuthorParseNodeKind._map[56] = "apnkRs2";
+ AuthorParseNodeKind.apnkRs2 = 56;
+ AuthorParseNodeKind._map[57] = "apnkNew";
+ AuthorParseNodeKind.apnkNew = 57;
+ AuthorParseNodeKind._map[58] = "apnkIndex";
+ AuthorParseNodeKind.apnkIndex = 58;
+ AuthorParseNodeKind._map[59] = "apnkQmark";
+ AuthorParseNodeKind.apnkQmark = 59;
+ AuthorParseNodeKind._map[60] = "apnkAsgAdd";
+ AuthorParseNodeKind.apnkAsgAdd = 60;
+ AuthorParseNodeKind._map[61] = "apnkAsgSub";
+ AuthorParseNodeKind.apnkAsgSub = 61;
+ AuthorParseNodeKind._map[62] = "apnkAsgMul";
+ AuthorParseNodeKind.apnkAsgMul = 62;
+ AuthorParseNodeKind._map[63] = "apnkAsgDiv";
+ AuthorParseNodeKind.apnkAsgDiv = 63;
+ AuthorParseNodeKind._map[64] = "apnkAsgMod";
+ AuthorParseNodeKind.apnkAsgMod = 64;
+ AuthorParseNodeKind._map[65] = "apnkAsgAnd";
+ AuthorParseNodeKind.apnkAsgAnd = 65;
+ AuthorParseNodeKind._map[66] = "apnkAsgXor";
+ AuthorParseNodeKind.apnkAsgXor = 66;
+ AuthorParseNodeKind._map[67] = "apnkAsgOr";
+ AuthorParseNodeKind.apnkAsgOr = 67;
+ AuthorParseNodeKind._map[68] = "apnkAsgLsh";
+ AuthorParseNodeKind.apnkAsgLsh = 68;
+ AuthorParseNodeKind._map[69] = "apnkAsgRsh";
+ AuthorParseNodeKind.apnkAsgRsh = 69;
+ AuthorParseNodeKind._map[70] = "apnkAsgRs2";
+ AuthorParseNodeKind.apnkAsgRs2 = 70;
+ AuthorParseNodeKind._map[71] = "apnkScope";
+ AuthorParseNodeKind.apnkScope = 71;
+ AuthorParseNodeKind._map[72] = "apnkMember";
+ AuthorParseNodeKind.apnkMember = 72;
+ AuthorParseNodeKind._map[73] = "apnkSetMember";
+ AuthorParseNodeKind.apnkSetMember = 73;
+ AuthorParseNodeKind._map[74] = "apnkGetMember";
+ AuthorParseNodeKind.apnkGetMember = 74;
+ AuthorParseNodeKind._map[75] = "apnkList";
+ AuthorParseNodeKind.apnkList = 75;
+ AuthorParseNodeKind._map[76] = "apnkVarDecl";
+ AuthorParseNodeKind.apnkVarDecl = 76;
+ AuthorParseNodeKind._map[77] = "apnkTemp";
+ AuthorParseNodeKind.apnkTemp = 77;
+ AuthorParseNodeKind._map[78] = "apnkFncDecl";
+ AuthorParseNodeKind.apnkFncDecl = 78;
+ AuthorParseNodeKind._map[79] = "apnkProg";
+ AuthorParseNodeKind.apnkProg = 79;
+ AuthorParseNodeKind._map[80] = "apnkEndCode";
+ AuthorParseNodeKind.apnkEndCode = 80;
+ AuthorParseNodeKind._map[81] = "apnkDebugger";
+ AuthorParseNodeKind.apnkDebugger = 81;
+ AuthorParseNodeKind._map[82] = "apnkFor";
+ AuthorParseNodeKind.apnkFor = 82;
+ AuthorParseNodeKind._map[83] = "apnkIf";
+ AuthorParseNodeKind.apnkIf = 83;
+ AuthorParseNodeKind._map[84] = "apnkWhile";
+ AuthorParseNodeKind.apnkWhile = 84;
+ AuthorParseNodeKind._map[85] = "apnkDoWhile";
+ AuthorParseNodeKind.apnkDoWhile = 85;
+ AuthorParseNodeKind._map[86] = "apnkForIn";
+ AuthorParseNodeKind.apnkForIn = 86;
+ AuthorParseNodeKind._map[87] = "apnkBlock";
+ AuthorParseNodeKind.apnkBlock = 87;
+ AuthorParseNodeKind._map[88] = "apnkWith";
+ AuthorParseNodeKind.apnkWith = 88;
+ AuthorParseNodeKind._map[89] = "apnkBreak";
+ AuthorParseNodeKind.apnkBreak = 89;
+ AuthorParseNodeKind._map[90] = "apnkContinue";
+ AuthorParseNodeKind.apnkContinue = 90;
+ AuthorParseNodeKind._map[91] = "apnkLabel";
+ AuthorParseNodeKind.apnkLabel = 91;
+ AuthorParseNodeKind._map[92] = "apnkSwitch";
+ AuthorParseNodeKind.apnkSwitch = 92;
+ AuthorParseNodeKind._map[93] = "apnkCase";
+ AuthorParseNodeKind.apnkCase = 93;
+ AuthorParseNodeKind._map[94] = "apnkTryCatch";
+ AuthorParseNodeKind.apnkTryCatch = 94;
+ AuthorParseNodeKind._map[95] = "apnkCatch";
+ AuthorParseNodeKind.apnkCatch = 95;
+ AuthorParseNodeKind._map[96] = "apnkReturn";
+ AuthorParseNodeKind.apnkReturn = 96;
+ AuthorParseNodeKind._map[97] = "apnkTry";
+ AuthorParseNodeKind.apnkTry = 97;
+ AuthorParseNodeKind._map[98] = "apnkThrow";
+ AuthorParseNodeKind.apnkThrow = 98;
+ AuthorParseNodeKind._map[99] = "apnkFinally";
+ AuthorParseNodeKind.apnkFinally = 99;
+ AuthorParseNodeKind._map[100] = "apnkTryFinally";
+ AuthorParseNodeKind.apnkTryFinally = 100;
+ AuthorParseNodeKind._map[101] = "apnkStruct";
+ AuthorParseNodeKind.apnkStruct = 101;
+ AuthorParseNodeKind._map[102] = "apnkEnum";
+ AuthorParseNodeKind.apnkEnum = 102;
+ AuthorParseNodeKind._map[103] = "apnkTyped";
+ AuthorParseNodeKind.apnkTyped = 103;
+ AuthorParseNodeKind._map[104] = "apnkVarDeclList";
+ AuthorParseNodeKind.apnkVarDeclList = 104;
+ AuthorParseNodeKind._map[105] = "apnkDefaultCase";
+ AuthorParseNodeKind.apnkDefaultCase = 105;
+ })(Formatting.AuthorParseNodeKind || (Formatting.AuthorParseNodeKind = {}));
+ var AuthorParseNodeKind = Formatting.AuthorParseNodeKind;
+ (function (AuthorTokenKind) {
+ AuthorTokenKind._map = [];
+ AuthorTokenKind._map[0] = "atkEnd";
+ AuthorTokenKind.atkEnd = 0;
+ AuthorTokenKind._map[1] = "atkText";
+ AuthorTokenKind.atkText = 1;
+ AuthorTokenKind._map[2] = "atkIdentifier";
+ AuthorTokenKind.atkIdentifier = 2;
+ AuthorTokenKind._map[3] = "atkComment";
+ AuthorTokenKind.atkComment = 3;
+ AuthorTokenKind._map[4] = "atkNumber";
+ AuthorTokenKind.atkNumber = 4;
+ AuthorTokenKind._map[5] = "atkString";
+ AuthorTokenKind.atkString = 5;
+ AuthorTokenKind._map[6] = "atkRegexp";
+ AuthorTokenKind.atkRegexp = 6;
+ AuthorTokenKind._map[7] = "atkConditionalComp";
+ AuthorTokenKind.atkConditionalComp = 7;
+ AuthorTokenKind._map[8] = "atkScanError";
+ AuthorTokenKind.atkScanError = 8;
+ AuthorTokenKind._map[9] = "atkSColon";
+ AuthorTokenKind.atkSColon = 9;
+ AuthorTokenKind._map[10] = "atkLParen";
+ AuthorTokenKind.atkLParen = 10;
+ AuthorTokenKind._map[11] = "atkRParen";
+ AuthorTokenKind.atkRParen = 11;
+ AuthorTokenKind._map[12] = "atkLBrack";
+ AuthorTokenKind.atkLBrack = 12;
+ AuthorTokenKind._map[13] = "atkRBrack";
+ AuthorTokenKind.atkRBrack = 13;
+ AuthorTokenKind._map[14] = "atkLCurly";
+ AuthorTokenKind.atkLCurly = 14;
+ AuthorTokenKind._map[15] = "atkRCurly";
+ AuthorTokenKind.atkRCurly = 15;
+ AuthorTokenKind._map[16] = "atkComma";
+ AuthorTokenKind.atkComma = 16;
+ AuthorTokenKind._map[17] = "atkArrow";
+ AuthorTokenKind.atkArrow = 17;
+ AuthorTokenKind._map[18] = "atkAsg";
+ AuthorTokenKind.atkAsg = 18;
+ AuthorTokenKind._map[19] = "atkAsgAdd";
+ AuthorTokenKind.atkAsgAdd = 19;
+ AuthorTokenKind._map[20] = "atkAsgSub";
+ AuthorTokenKind.atkAsgSub = 20;
+ AuthorTokenKind._map[21] = "atkAsgMul";
+ AuthorTokenKind.atkAsgMul = 21;
+ AuthorTokenKind._map[22] = "atkAsgDiv";
+ AuthorTokenKind.atkAsgDiv = 22;
+ AuthorTokenKind._map[23] = "atkAsgMod";
+ AuthorTokenKind.atkAsgMod = 23;
+ AuthorTokenKind._map[24] = "atkAsgAnd";
+ AuthorTokenKind.atkAsgAnd = 24;
+ AuthorTokenKind._map[25] = "atkAsgXor";
+ AuthorTokenKind.atkAsgXor = 25;
+ AuthorTokenKind._map[26] = "atkAsgOr";
+ AuthorTokenKind.atkAsgOr = 26;
+ AuthorTokenKind._map[27] = "atkAsgLsh";
+ AuthorTokenKind.atkAsgLsh = 27;
+ AuthorTokenKind._map[28] = "atkAsgRsh";
+ AuthorTokenKind.atkAsgRsh = 28;
+ AuthorTokenKind._map[29] = "atkAsgRs2";
+ AuthorTokenKind.atkAsgRs2 = 29;
+ AuthorTokenKind._map[30] = "atkQMark";
+ AuthorTokenKind.atkQMark = 30;
+ AuthorTokenKind._map[31] = "atkColon";
+ AuthorTokenKind.atkColon = 31;
+ AuthorTokenKind._map[32] = "atkLogOr";
+ AuthorTokenKind.atkLogOr = 32;
+ AuthorTokenKind._map[33] = "atkLogAnd";
+ AuthorTokenKind.atkLogAnd = 33;
+ AuthorTokenKind._map[34] = "atkOr";
+ AuthorTokenKind.atkOr = 34;
+ AuthorTokenKind._map[35] = "atkXor";
+ AuthorTokenKind.atkXor = 35;
+ AuthorTokenKind._map[36] = "atkAnd";
+ AuthorTokenKind.atkAnd = 36;
+ AuthorTokenKind._map[37] = "atkEQ";
+ AuthorTokenKind.atkEQ = 37;
+ AuthorTokenKind._map[38] = "atkNE";
+ AuthorTokenKind.atkNE = 38;
+ AuthorTokenKind._map[39] = "atkEqv";
+ AuthorTokenKind.atkEqv = 39;
+ AuthorTokenKind._map[40] = "atkNEqv";
+ AuthorTokenKind.atkNEqv = 40;
+ AuthorTokenKind._map[41] = "atkLT";
+ AuthorTokenKind.atkLT = 41;
+ AuthorTokenKind._map[42] = "atkLE";
+ AuthorTokenKind.atkLE = 42;
+ AuthorTokenKind._map[43] = "atkGT";
+ AuthorTokenKind.atkGT = 43;
+ AuthorTokenKind._map[44] = "atkGE";
+ AuthorTokenKind.atkGE = 44;
+ AuthorTokenKind._map[45] = "atkLsh";
+ AuthorTokenKind.atkLsh = 45;
+ AuthorTokenKind._map[46] = "atkRsh";
+ AuthorTokenKind.atkRsh = 46;
+ AuthorTokenKind._map[47] = "atkRs2";
+ AuthorTokenKind.atkRs2 = 47;
+ AuthorTokenKind._map[48] = "atkAdd";
+ AuthorTokenKind.atkAdd = 48;
+ AuthorTokenKind._map[49] = "atkSub";
+ AuthorTokenKind.atkSub = 49;
+ AuthorTokenKind._map[50] = "atkMult";
+ AuthorTokenKind.atkMult = 50;
+ AuthorTokenKind._map[51] = "atkDiv";
+ AuthorTokenKind.atkDiv = 51;
+ AuthorTokenKind._map[52] = "atkPct";
+ AuthorTokenKind.atkPct = 52;
+ AuthorTokenKind._map[53] = "atkTilde";
+ AuthorTokenKind.atkTilde = 53;
+ AuthorTokenKind._map[54] = "atkBang";
+ AuthorTokenKind.atkBang = 54;
+ AuthorTokenKind._map[55] = "atkInc";
+ AuthorTokenKind.atkInc = 55;
+ AuthorTokenKind._map[56] = "atkDec";
+ AuthorTokenKind.atkDec = 56;
+ AuthorTokenKind._map[57] = "atkDot";
+ AuthorTokenKind.atkDot = 57;
+ AuthorTokenKind._map[58] = "atkScope";
+ AuthorTokenKind.atkScope = 58;
+ AuthorTokenKind._map[59] = "atkEllipsis";
+ AuthorTokenKind.atkEllipsis = 59;
+ AuthorTokenKind._map[60] = "atkBreak";
+ AuthorTokenKind.atkBreak = 60;
+ AuthorTokenKind._map[61] = "atkCase";
+ AuthorTokenKind.atkCase = 61;
+ AuthorTokenKind._map[62] = "atkCatch";
+ AuthorTokenKind.atkCatch = 62;
+ AuthorTokenKind._map[63] = "atkClass";
+ AuthorTokenKind.atkClass = 63;
+ AuthorTokenKind._map[64] = "atkConst";
+ AuthorTokenKind.atkConst = 64;
+ AuthorTokenKind._map[65] = "atkContinue";
+ AuthorTokenKind.atkContinue = 65;
+ AuthorTokenKind._map[66] = "atkDebugger";
+ AuthorTokenKind.atkDebugger = 66;
+ AuthorTokenKind._map[67] = "atkDefault";
+ AuthorTokenKind.atkDefault = 67;
+ AuthorTokenKind._map[68] = "atkDelete";
+ AuthorTokenKind.atkDelete = 68;
+ AuthorTokenKind._map[69] = "atkDo";
+ AuthorTokenKind.atkDo = 69;
+ AuthorTokenKind._map[70] = "atkElse";
+ AuthorTokenKind.atkElse = 70;
+ AuthorTokenKind._map[71] = "atkEnum";
+ AuthorTokenKind.atkEnum = 71;
+ AuthorTokenKind._map[72] = "atkExport";
+ AuthorTokenKind.atkExport = 72;
+ AuthorTokenKind._map[73] = "atkExtends";
+ AuthorTokenKind.atkExtends = 73;
+ AuthorTokenKind._map[74] = "atkFalse";
+ AuthorTokenKind.atkFalse = 74;
+ AuthorTokenKind._map[75] = "atkFinally";
+ AuthorTokenKind.atkFinally = 75;
+ AuthorTokenKind._map[76] = "atkFor";
+ AuthorTokenKind.atkFor = 76;
+ AuthorTokenKind._map[77] = "atkFunction";
+ AuthorTokenKind.atkFunction = 77;
+ AuthorTokenKind._map[78] = "atkIf";
+ AuthorTokenKind.atkIf = 78;
+ AuthorTokenKind._map[79] = "atkImport";
+ AuthorTokenKind.atkImport = 79;
+ AuthorTokenKind._map[80] = "atkIn";
+ AuthorTokenKind.atkIn = 80;
+ AuthorTokenKind._map[81] = "atkInstanceof";
+ AuthorTokenKind.atkInstanceof = 81;
+ AuthorTokenKind._map[82] = "atkNew";
+ AuthorTokenKind.atkNew = 82;
+ AuthorTokenKind._map[83] = "atkNull";
+ AuthorTokenKind.atkNull = 83;
+ AuthorTokenKind._map[84] = "atkReturn";
+ AuthorTokenKind.atkReturn = 84;
+ AuthorTokenKind._map[85] = "atkSuper";
+ AuthorTokenKind.atkSuper = 85;
+ AuthorTokenKind._map[86] = "atkSwitch";
+ AuthorTokenKind.atkSwitch = 86;
+ AuthorTokenKind._map[87] = "atkThis";
+ AuthorTokenKind.atkThis = 87;
+ AuthorTokenKind._map[88] = "atkThrow";
+ AuthorTokenKind.atkThrow = 88;
+ AuthorTokenKind._map[89] = "atkTrue";
+ AuthorTokenKind.atkTrue = 89;
+ AuthorTokenKind._map[90] = "atkTry";
+ AuthorTokenKind.atkTry = 90;
+ AuthorTokenKind._map[91] = "atkTypeof";
+ AuthorTokenKind.atkTypeof = 91;
+ AuthorTokenKind._map[92] = "atkVar";
+ AuthorTokenKind.atkVar = 92;
+ AuthorTokenKind._map[93] = "atkVoid";
+ AuthorTokenKind.atkVoid = 93;
+ AuthorTokenKind._map[94] = "atkWhile";
+ AuthorTokenKind.atkWhile = 94;
+ AuthorTokenKind._map[95] = "atkWith";
+ AuthorTokenKind.atkWith = 95;
+ AuthorTokenKind._map[96] = "atkConstructor";
+ AuthorTokenKind.atkConstructor = 96;
+ AuthorTokenKind._map[97] = "atkDeclare";
+ AuthorTokenKind.atkDeclare = 97;
+ AuthorTokenKind._map[98] = "atkModule";
+ AuthorTokenKind.atkModule = 98;
+ AuthorTokenKind._map[99] = "atkGet";
+ AuthorTokenKind.atkGet = 99;
+ AuthorTokenKind._map[100] = "atkSet";
+ AuthorTokenKind.atkSet = 100;
+ AuthorTokenKind._map[101] = "atkImplements";
+ AuthorTokenKind.atkImplements = 101;
+ AuthorTokenKind._map[102] = "atkInterface";
+ AuthorTokenKind.atkInterface = 102;
+ AuthorTokenKind._map[103] = "atkLet";
+ AuthorTokenKind.atkLet = 103;
+ AuthorTokenKind._map[104] = "atkPackage";
+ AuthorTokenKind.atkPackage = 104;
+ AuthorTokenKind._map[105] = "atkPrivate";
+ AuthorTokenKind.atkPrivate = 105;
+ AuthorTokenKind._map[106] = "atkProtected";
+ AuthorTokenKind.atkProtected = 106;
+ AuthorTokenKind._map[107] = "atkPublic";
+ AuthorTokenKind.atkPublic = 107;
+ AuthorTokenKind._map[108] = "atkStatic";
+ AuthorTokenKind.atkStatic = 108;
+ AuthorTokenKind._map[109] = "atkYield";
+ AuthorTokenKind.atkYield = 109;
+ AuthorTokenKind._map[110] = "Length";
+ AuthorTokenKind.Length = 110;
+ })(Formatting.AuthorTokenKind || (Formatting.AuthorTokenKind = {}));
+ var AuthorTokenKind = Formatting.AuthorTokenKind;
+ (function (AuthorParseNodeEdge) {
+ AuthorParseNodeEdge._map = [];
+ AuthorParseNodeEdge._map[0] = "apneNone";
+ AuthorParseNodeEdge.apneNone = 0;
+ AuthorParseNodeEdge._map[1] = "apneOperand";
+ AuthorParseNodeEdge.apneOperand = 1;
+ AuthorParseNodeEdge._map[2] = "apneLeft";
+ AuthorParseNodeEdge.apneLeft = 2;
+ AuthorParseNodeEdge._map[3] = "apneRight";
+ AuthorParseNodeEdge.apneRight = 3;
+ AuthorParseNodeEdge._map[4] = "apneCondition";
+ AuthorParseNodeEdge.apneCondition = 4;
+ AuthorParseNodeEdge._map[5] = "apneThen";
+ AuthorParseNodeEdge.apneThen = 5;
+ AuthorParseNodeEdge._map[6] = "apneElse";
+ AuthorParseNodeEdge.apneElse = 6;
+ AuthorParseNodeEdge._map[7] = "apneInitialization";
+ AuthorParseNodeEdge.apneInitialization = 7;
+ AuthorParseNodeEdge._map[8] = "apneIncrement";
+ AuthorParseNodeEdge.apneIncrement = 8;
+ AuthorParseNodeEdge._map[9] = "apneBody";
+ AuthorParseNodeEdge.apneBody = 9;
+ AuthorParseNodeEdge._map[10] = "apneBlockBody";
+ AuthorParseNodeEdge.apneBlockBody = 10;
+ AuthorParseNodeEdge._map[11] = "apneValue";
+ AuthorParseNodeEdge.apneValue = 11;
+ AuthorParseNodeEdge._map[12] = "apneTarget";
+ AuthorParseNodeEdge.apneTarget = 12;
+ AuthorParseNodeEdge._map[13] = "apneArgument";
+ AuthorParseNodeEdge.apneArgument = 13;
+ AuthorParseNodeEdge._map[14] = "apneArguments";
+ AuthorParseNodeEdge.apneArguments = 14;
+ AuthorParseNodeEdge._map[15] = "apneMembers";
+ AuthorParseNodeEdge.apneMembers = 15;
+ AuthorParseNodeEdge._map[16] = "apneVariable";
+ AuthorParseNodeEdge.apneVariable = 16;
+ AuthorParseNodeEdge._map[17] = "apneObject";
+ AuthorParseNodeEdge.apneObject = 17;
+ AuthorParseNodeEdge._map[18] = "apneTry";
+ AuthorParseNodeEdge.apneTry = 18;
+ AuthorParseNodeEdge._map[19] = "apneCatch";
+ AuthorParseNodeEdge.apneCatch = 19;
+ AuthorParseNodeEdge._map[20] = "apneFinally";
+ AuthorParseNodeEdge.apneFinally = 20;
+ AuthorParseNodeEdge._map[21] = "apneCase";
+ AuthorParseNodeEdge.apneCase = 21;
+ AuthorParseNodeEdge._map[22] = "apneDefaultCase";
+ AuthorParseNodeEdge.apneDefaultCase = 22;
+ AuthorParseNodeEdge._map[23] = "apneElements";
+ AuthorParseNodeEdge.apneElements = 23;
+ AuthorParseNodeEdge._map[24] = "apneListItem";
+ AuthorParseNodeEdge.apneListItem = 24;
+ AuthorParseNodeEdge._map[25] = "apneMember";
+ AuthorParseNodeEdge.apneMember = 25;
+ AuthorParseNodeEdge._map[26] = "apneType";
+ AuthorParseNodeEdge.apneType = 26;
+ })(Formatting.AuthorParseNodeEdge || (Formatting.AuthorParseNodeEdge = {}));
+ var AuthorParseNodeEdge = Formatting.AuthorParseNodeEdge;
+ var AuthorParseNodeSet = (function () {
+ function AuthorParseNodeSet(nodes) {
+ this.nodes = nodes;
+ }
+ AuthorParseNodeSet.prototype.Count = function () {
+ return this.nodes.length;
+ };
+ AuthorParseNodeSet.prototype.GetItems = function (startIndex, count) {
+ if(startIndex == 0 && count == this.nodes.length) {
+ return this.nodes;
+ }
+ throw new Error("Invalid call to GetItems");
+ };
+ return AuthorParseNodeSet;
+ })();
+ Formatting.AuthorParseNodeSet = AuthorParseNodeSet;
+ (function (AuthorParseNodeProperty) {
+ AuthorParseNodeProperty._map = [];
+ AuthorParseNodeProperty._map[0] = "apnpLCurlyMin";
+ AuthorParseNodeProperty.apnpLCurlyMin = 0;
+ AuthorParseNodeProperty._map[1] = "apnpRCurlyMin";
+ AuthorParseNodeProperty.apnpRCurlyMin = 1;
+ AuthorParseNodeProperty._map[2] = "apnpLParenMin";
+ AuthorParseNodeProperty.apnpLParenMin = 2;
+ AuthorParseNodeProperty._map[3] = "apnpRParenMin";
+ AuthorParseNodeProperty.apnpRParenMin = 3;
+ AuthorParseNodeProperty._map[4] = "apnpLBrackMin";
+ AuthorParseNodeProperty.apnpLBrackMin = 4;
+ AuthorParseNodeProperty._map[5] = "apnpRBrackMin";
+ AuthorParseNodeProperty.apnpRBrackMin = 5;
+ AuthorParseNodeProperty._map[6] = "apnpIdentifierMin";
+ AuthorParseNodeProperty.apnpIdentifierMin = 6;
+ AuthorParseNodeProperty._map[7] = "apnpFunctionKeywordMin";
+ AuthorParseNodeProperty.apnpFunctionKeywordMin = 7;
+ })(Formatting.AuthorParseNodeProperty || (Formatting.AuthorParseNodeProperty = {}));
+ var AuthorParseNodeProperty = Formatting.AuthorParseNodeProperty;
+ var AuthorTokenKindMap = (function () {
+ function AuthorTokenKindMap() {
+ this.tokenMap = [];
+ this.init();
+ }
+ AuthorTokenKindMap.instance = null;
+ AuthorTokenKindMap.getInstance = function getInstance() {
+ if(AuthorTokenKindMap.instance === null) {
+ AuthorTokenKindMap.instance = new AuthorTokenKindMap();
+ }
+ return AuthorTokenKindMap.instance;
+ };
+ AuthorTokenKindMap.prototype.init = function () {
+ for(var i = 0, len = TypeScript.TokenID.Lim; i < len; i++) {
+ this.tokenMap[i] = this.mapTokenID(i);
+ }
+ };
+ AuthorTokenKindMap.prototype.getTokenKind = function (kind) {
+ return this.tokenMap[kind];
+ };
+ AuthorTokenKindMap.prototype.mapTokenID = function (kind) {
+ switch(kind) {
+ case TypeScript.TokenID.Any:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.Bool:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.Break:
+ return AuthorTokenKind.atkBreak;
+ case TypeScript.TokenID.Case:
+ return AuthorTokenKind.atkCase;
+ case TypeScript.TokenID.Catch:
+ return AuthorTokenKind.atkCatch;
+ case TypeScript.TokenID.Class:
+ return AuthorTokenKind.atkClass;
+ case TypeScript.TokenID.Const:
+ return AuthorTokenKind.atkConst;
+ case TypeScript.TokenID.Continue:
+ return AuthorTokenKind.atkContinue;
+ case TypeScript.TokenID.Debugger:
+ return AuthorTokenKind.atkDebugger;
+ case TypeScript.TokenID.Default:
+ return AuthorTokenKind.atkDefault;
+ case TypeScript.TokenID.Delete:
+ return AuthorTokenKind.atkDelete;
+ case TypeScript.TokenID.Do:
+ return AuthorTokenKind.atkDo;
+ case TypeScript.TokenID.Else:
+ return AuthorTokenKind.atkElse;
+ case TypeScript.TokenID.Enum:
+ return AuthorTokenKind.atkEnum;
+ case TypeScript.TokenID.Export:
+ return AuthorTokenKind.atkExport;
+ case TypeScript.TokenID.Extends:
+ return AuthorTokenKind.atkExtends;
+ case TypeScript.TokenID.Declare:
+ return AuthorTokenKind.atkDeclare;
+ case TypeScript.TokenID.False:
+ return AuthorTokenKind.atkFalse;
+ case TypeScript.TokenID.Finally:
+ return AuthorTokenKind.atkFinally;
+ case TypeScript.TokenID.For:
+ return AuthorTokenKind.atkFor;
+ case TypeScript.TokenID.Constructor:
+ return AuthorTokenKind.atkConstructor;
+ case TypeScript.TokenID.Function:
+ return AuthorTokenKind.atkFunction;
+ case TypeScript.TokenID.Get:
+ return AuthorTokenKind.atkGet;
+ case TypeScript.TokenID.If:
+ return AuthorTokenKind.atkIf;
+ case TypeScript.TokenID.Implements:
+ return AuthorTokenKind.atkImplements;
+ case TypeScript.TokenID.Import:
+ return AuthorTokenKind.atkImport;
+ case TypeScript.TokenID.In:
+ return AuthorTokenKind.atkIn;
+ case TypeScript.TokenID.InstanceOf:
+ return AuthorTokenKind.atkInstanceof;
+ case TypeScript.TokenID.Interface:
+ return AuthorTokenKind.atkInterface;
+ case TypeScript.TokenID.Let:
+ return AuthorTokenKind.atkLet;
+ case TypeScript.TokenID.Module:
+ return AuthorTokenKind.atkModule;
+ case TypeScript.TokenID.New:
+ return AuthorTokenKind.atkNew;
+ case TypeScript.TokenID.Number:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.Null:
+ return AuthorTokenKind.atkNull;
+ case TypeScript.TokenID.Package:
+ return AuthorTokenKind.atkPackage;
+ case TypeScript.TokenID.Private:
+ return AuthorTokenKind.atkPrivate;
+ case TypeScript.TokenID.Protected:
+ return AuthorTokenKind.atkProtected;
+ case TypeScript.TokenID.Public:
+ return AuthorTokenKind.atkPublic;
+ case TypeScript.TokenID.With:
+ return AuthorTokenKind.atkWith;
+ case TypeScript.TokenID.Return:
+ return AuthorTokenKind.atkReturn;
+ case TypeScript.TokenID.Set:
+ return AuthorTokenKind.atkSet;
+ case TypeScript.TokenID.Static:
+ return AuthorTokenKind.atkStatic;
+ case TypeScript.TokenID.String:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.Super:
+ return AuthorTokenKind.atkSuper;
+ case TypeScript.TokenID.Switch:
+ return AuthorTokenKind.atkSwitch;
+ case TypeScript.TokenID.This:
+ return AuthorTokenKind.atkThis;
+ case TypeScript.TokenID.Throw:
+ return AuthorTokenKind.atkThrow;
+ case TypeScript.TokenID.True:
+ return AuthorTokenKind.atkTrue;
+ case TypeScript.TokenID.Try:
+ return AuthorTokenKind.atkTry;
+ case TypeScript.TokenID.TypeOf:
+ return AuthorTokenKind.atkTypeof;
+ case TypeScript.TokenID.Var:
+ return AuthorTokenKind.atkVar;
+ case TypeScript.TokenID.Void:
+ return AuthorTokenKind.atkVoid;
+ case TypeScript.TokenID.While:
+ return AuthorTokenKind.atkWhile;
+ case TypeScript.TokenID.Yield:
+ return AuthorTokenKind.atkYield;
+ case TypeScript.TokenID.Semicolon:
+ return AuthorTokenKind.atkSColon;
+ case TypeScript.TokenID.OpenParen:
+ return AuthorTokenKind.atkLParen;
+ case TypeScript.TokenID.CloseParen:
+ return AuthorTokenKind.atkRParen;
+ case TypeScript.TokenID.OpenBracket:
+ return AuthorTokenKind.atkLBrack;
+ case TypeScript.TokenID.CloseBracket:
+ return AuthorTokenKind.atkRBrack;
+ case TypeScript.TokenID.OpenBrace:
+ return AuthorTokenKind.atkLCurly;
+ case TypeScript.TokenID.CloseBrace:
+ return AuthorTokenKind.atkRCurly;
+ case TypeScript.TokenID.Comma:
+ return AuthorTokenKind.atkComma;
+ case TypeScript.TokenID.Equals:
+ return AuthorTokenKind.atkAsg;
+ case TypeScript.TokenID.PlusEquals:
+ return AuthorTokenKind.atkAsgAdd;
+ case TypeScript.TokenID.MinusEquals:
+ return AuthorTokenKind.atkAsgSub;
+ case TypeScript.TokenID.AsteriskEquals:
+ return AuthorTokenKind.atkAsgMul;
+ case TypeScript.TokenID.SlashEquals:
+ return AuthorTokenKind.atkAsgDiv;
+ case TypeScript.TokenID.PercentEquals:
+ return AuthorTokenKind.atkAsgMod;
+ case TypeScript.TokenID.AmpersandEquals:
+ return AuthorTokenKind.atkAsgAnd;
+ case TypeScript.TokenID.CaretEquals:
+ return AuthorTokenKind.atkAsgXor;
+ case TypeScript.TokenID.BarEquals:
+ return AuthorTokenKind.atkAsgOr;
+ case TypeScript.TokenID.LessThanLessThanEquals:
+ return AuthorTokenKind.atkAsgLsh;
+ case TypeScript.TokenID.GreaterThanGreaterThanEquals:
+ return AuthorTokenKind.atkAsgRsh;
+ case TypeScript.TokenID.GreaterThanGreaterThanGreaterThanEquals:
+ return AuthorTokenKind.atkAsgRs2;
+ case TypeScript.TokenID.Question:
+ return AuthorTokenKind.atkQMark;
+ case TypeScript.TokenID.Colon:
+ return AuthorTokenKind.atkColon;
+ case TypeScript.TokenID.BarBar:
+ return AuthorTokenKind.atkLogOr;
+ case TypeScript.TokenID.AmpersandAmpersand:
+ return AuthorTokenKind.atkLogAnd;
+ case TypeScript.TokenID.Bar:
+ return AuthorTokenKind.atkOr;
+ case TypeScript.TokenID.Caret:
+ return AuthorTokenKind.atkXor;
+ case TypeScript.TokenID.And:
+ return AuthorTokenKind.atkAnd;
+ case TypeScript.TokenID.EqualsEquals:
+ return AuthorTokenKind.atkEQ;
+ case TypeScript.TokenID.ExclamationEquals:
+ return AuthorTokenKind.atkNE;
+ case TypeScript.TokenID.EqualsEqualsEquals:
+ return AuthorTokenKind.atkEqv;
+ case TypeScript.TokenID.ExclamationEqualsEquals:
+ return AuthorTokenKind.atkNEqv;
+ case TypeScript.TokenID.LessThan:
+ return AuthorTokenKind.atkLT;
+ case TypeScript.TokenID.LessThanEquals:
+ return AuthorTokenKind.atkLE;
+ case TypeScript.TokenID.GreaterThan:
+ return AuthorTokenKind.atkGT;
+ case TypeScript.TokenID.GreaterThanEquals:
+ return AuthorTokenKind.atkGE;
+ case TypeScript.TokenID.LessThanLessThan:
+ return AuthorTokenKind.atkLsh;
+ case TypeScript.TokenID.GreaterThanGreaterThan:
+ return AuthorTokenKind.atkRsh;
+ case TypeScript.TokenID.GreaterThanGreaterThanGreaterThan:
+ return AuthorTokenKind.atkRs2;
+ case TypeScript.TokenID.Plus:
+ return AuthorTokenKind.atkAdd;
+ case TypeScript.TokenID.Minus:
+ return AuthorTokenKind.atkSub;
+ case TypeScript.TokenID.Asterisk:
+ return AuthorTokenKind.atkMult;
+ case TypeScript.TokenID.Slash:
+ return AuthorTokenKind.atkDiv;
+ case TypeScript.TokenID.Percent:
+ return AuthorTokenKind.atkPct;
+ case TypeScript.TokenID.Tilde:
+ return AuthorTokenKind.atkTilde;
+ case TypeScript.TokenID.Exclamation:
+ return AuthorTokenKind.atkBang;
+ case TypeScript.TokenID.PlusPlus:
+ return AuthorTokenKind.atkInc;
+ case TypeScript.TokenID.MinusMinus:
+ return AuthorTokenKind.atkDec;
+ case TypeScript.TokenID.Dot:
+ return AuthorTokenKind.atkDot;
+ case TypeScript.TokenID.DotDotDot:
+ return AuthorTokenKind.atkEllipsis;
+ case TypeScript.TokenID.Error:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.EndOfFile:
+ return AuthorTokenKind.atkEnd;
+ case TypeScript.TokenID.EqualsGreaterThan:
+ return AuthorTokenKind.atkArrow;
+ case TypeScript.TokenID.Identifier:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.StringLiteral:
+ return AuthorTokenKind.atkString;
+ case TypeScript.TokenID.RegularExpressionLiteral:
+ return AuthorTokenKind.atkRegexp;
+ case TypeScript.TokenID.NumberLiteral:
+ return AuthorTokenKind.atkNumber;
+ case TypeScript.TokenID.Whitespace:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.Comment:
+ return AuthorTokenKind.atkComment;
+ default:
+ throw new Error("Invalid token kind:" + kind + " (" + (TypeScript.TokenID)._map[kind] + ")");
+ }
+ };
+ return AuthorTokenKindMap;
+ })();
+ Formatting.AuthorTokenKindMap = AuthorTokenKindMap;
+ var Debug = (function () {
+ function Debug() { }
+ Debug.Assert = function Assert(cond, msg) {
+ if(!cond) {
+ throw new Error("assertion failure: " + msg);
+ }
+ };
+ Debug.Fail = function Fail(msg) {
+ Debug.Assert(false, msg);
+ };
+ return Debug;
+ })();
+ Formatting.Debug = Debug;
+ var HashSet_int = (function () {
+ function HashSet_int() {
+ this.items = [];
+ }
+ HashSet_int.prototype.Contains = function (item) {
+ return this.items[item] !== undefined;
+ };
+ HashSet_int.prototype.Add = function (item) {
+ this.items[item] = item;
+ };
+ return HashSet_int;
+ })();
+ Formatting.HashSet_int = HashSet_int;
+ var Dictionary_int_List_IndentationEditInfo = (function () {
+ function Dictionary_int_List_IndentationEditInfo() {
+ this.items = [];
+ }
+ Dictionary_int_List_IndentationEditInfo.prototype.GetValue = function (key) {
+ var result = this.items[key];
+ return result === undefined ? null : result;
+ };
+ Dictionary_int_List_IndentationEditInfo.prototype.Add = function (key, value) {
+ this.items[key] = value;
+ };
+ return Dictionary_int_List_IndentationEditInfo;
+ })();
+ Formatting.Dictionary_int_List_IndentationEditInfo = Dictionary_int_List_IndentationEditInfo;
+ var Dictionary_int_int = (function () {
+ function Dictionary_int_int() {
+ this.items = [];
+ }
+ Dictionary_int_int.prototype.GetValue = function (key) {
+ var result = this.items[key];
+ return result === undefined ? null : result;
+ };
+ Dictionary_int_int.prototype.Add = function (key, value) {
+ this.items[key] = value;
+ };
+ return Dictionary_int_int;
+ })();
+ Formatting.Dictionary_int_int = Dictionary_int_int;
+ var Math = (function () {
+ function Math() { }
+ Math.Max = function Max(x, y) {
+ return (x > y ? x : y);
+ };
+ Math.Min = function Min(x, y) {
+ return (x < y ? x : y);
+ };
+ return Math;
+ })();
+ Formatting.Math = Math;
+ var StringUtils = (function () {
+ function StringUtils() { }
+ StringUtils.IndexOf = function IndexOf(value, search, startIndex) {
+ if (typeof startIndex === "undefined") { startIndex = 0; }
+ return value.indexOf(search, startIndex);
+ };
+ StringUtils.Equals = function Equals(x, y) {
+ return x == y;
+ };
+ StringUtils.IsNullOrEmpty = function IsNullOrEmpty(x) {
+ return x === null || x === "";
+ };
+ StringUtils.IsWhiteSpace = function IsWhiteSpace(charCode) {
+ return EditorUtilities.IsWhitespace(charCode);
+ };
+ StringUtils.create = function create(value, count) {
+ var result = "";
+ for(var i = 0; i < count; i++) {
+ result += value;
+ }
+ return result;
+ };
+ StringUtils.foreach = function foreach(x, action) {
+ for(var i = 0; i < x.length; i++) {
+ action(x.charAt(i));
+ }
+ };
+ return StringUtils;
+ })();
+ Formatting.StringUtils = StringUtils;
+ var EditorUtilities = (function () {
+ function EditorUtilities() { }
+ EditorUtilities.IsWhitespace = function IsWhitespace(charCode) {
+ switch(charCode) {
+ case 0x0009:
+ case 0x000b:
+ case 0x000c:
+ case 0xfeff:
+ case 0x0020:
+ case 0x00a0:
+ case 0x1680:
+ case 0x2000:
+ case 0x2001:
+ case 0x2002:
+ case 0x2003:
+ case 0x2004:
+ case 0x2005:
+ case 0x2006:
+ case 0x2007:
+ case 0x2008:
+ case 0x2009:
+ case 0x200a:
+ case 0x202f:
+ case 0x200b:
+ case 0x3000:
+ case 0x180e:
+ case 0x205f:
+ return true;
+ default:
+ return false;
+ }
+ };
+ return EditorUtilities;
+ })();
+ Formatting.EditorUtilities = EditorUtilities;
+ function getTokensInSpan(logger, scriptSyntaxAST, tokenKindMap, span) {
+ var tokens = new List_TokenSpan();
+ var tokenStream = scriptSyntaxAST.getTokenStream(span.startPosition());
+ while(tokenStream.moveNext()) {
+ if(logger.information()) {
+ var text = "token: " + (TypeScript.TokenID)._map[tokenStream.tokenId()] + " - startPos=" + tokenStream.tokenStartPos() + ", pos=" + tokenStream.tokenEndPos();
+ logger.log(text);
+ }
+ var endPos = tokenStream.tokenEndPos();
+ if(endPos < span.startPosition()) {
+ continue;
+ }
+ var startPos = tokenStream.tokenStartPos();
+ if(startPos > span.endPosition()) {
+ break;
+ }
+ var kind = tokenKindMap.getTokenKind(tokenStream.tokenId());
+ var tokenSpan = new Formatting.TokenSpan(kind, tokenStream.tokenId(), new SnapshotSpan(span.snapshot, Span.FromBounds(startPos, endPos)));
+ tokens.add(tokenSpan);
+ }
+ logger.log("GetTokens([" + span.startPosition() + "," + span.endPosition() + "]): returned " + tokens.count() + " tokens from source text offset " + tokenStream.sourceTextOffset());
+ return tokens;
+ }
+ Formatting.getTokensInSpan = getTokensInSpan;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var FormattingContext = (function () {
+ function FormattingContext(fileAuthoringProxy, snapshot, tokens, formattingRequestKind) {
+ this.fileAuthoringProxy = fileAuthoringProxy;
+ this.snapshot = snapshot;
+ this.tokens = tokens;
+ this.formattingRequestKind = formattingRequestKind;
+ this.contextNode = null;
+ this.tokenSpan = null;
+ this.nextTokenSpan = null;
+ this.contextNodeAllOnSameLine = undefined;
+ this.tokensAreOnSameLine = undefined;
+ this.tokensAreSiblingNodesOnSameLine = undefined;
+ Formatting.Debug.Assert(this.snapshot != null, "snapshot is null");
+ Formatting.Debug.Assert(this.tokens != null, "tokens is null");
+ }
+ FormattingContext.prototype.findTokenAtPosition = function (position) {
+ var index = Formatting.BinarySearch(this.tokens, position, function (position, tokenSpan) {
+ if(position < tokenSpan.Span.startPosition()) {
+ return -1;
+ } else if(position < tokenSpan.Span.endPosition()) {
+ return 0;
+ } else {
+ return 1;
+ }
+ });
+ if(index < 0) {
+ return null;
+ } else {
+ return this.tokens.get(index);
+ }
+ };
+ FormattingContext.prototype.setContext = function (node, t1, t2) {
+ Formatting.Debug.Assert(node != null, "node is null");
+ Formatting.Debug.Assert(t1 != null, "t1 is null");
+ Formatting.Debug.Assert(t2 != null, "t2 is null");
+ this.contextNode = node;
+ this.tokenSpan = t1;
+ this.nextTokenSpan = t2;
+ this.contextNodeAllOnSameLine = undefined;
+ this.tokensAreOnSameLine = undefined;
+ this.tokensAreSiblingNodesOnSameLine = undefined;
+ };
+ FormattingContext.prototype.ContextNodeAllOnSameLine = function () {
+ if(this.contextNodeAllOnSameLine === undefined) {
+ var blockSpan = this.contextNode.GetBlockSpan(this.fileAuthoringProxy, this.tokens);
+ var openToken = this.findTokenAtPosition(blockSpan.start());
+ if(openToken != null && openToken.tokenID == TypeScript.TokenID.OpenBrace) {
+ var closeToken = this.findTokenAtPosition(blockSpan.end() - 1);
+ if(closeToken == null || closeToken.tokenID != TypeScript.TokenID.CloseBrace) {
+ for(var position = blockSpan.end() - 2; position > openToken.Span.endPosition(); position--) {
+ closeToken = this.findTokenAtPosition(position);
+ if(closeToken != null) {
+ blockSpan = Formatting.Span.FromBounds(openToken.Span.startPosition(), closeToken.Span.endPosition());
+ break;
+ }
+ }
+ }
+ }
+ var startLine = this.snapshot.GetLineNumberFromPosition(blockSpan.start());
+ var endLine = this.snapshot.GetLineNumberFromPosition(blockSpan.end());
+ this.contextNodeAllOnSameLine = (startLine == endLine);
+ }
+ return this.contextNodeAllOnSameLine;
+ };
+ FormattingContext.prototype.TokensAreOnSameLine = function () {
+ if(this.tokensAreOnSameLine === undefined) {
+ var startLine = this.tokenSpan.lineNumber();
+ var endLine = this.nextTokenSpan.lineNumber();
+ this.tokensAreOnSameLine = (startLine == endLine);
+ }
+ return this.tokensAreOnSameLine;
+ };
+ FormattingContext.prototype.TokensAreSiblingNodesOnSameLine = function () {
+ if(this.tokensAreSiblingNodesOnSameLine === undefined) {
+ this.tokensAreSiblingNodesOnSameLine = this.AreTokensSiblingNodesOnSameLine();
+ }
+ return this.tokensAreSiblingNodesOnSameLine;
+ };
+ FormattingContext.prototype.AreTokensSiblingNodesOnSameLine = function () {
+ if(this.contextNode.children() == null || this.contextNode.children().count() < 2) {
+ return false;
+ }
+ var current = null;
+ var sibling = null;
+ var nodeIndex = Formatting.ParseNodeExtensions.TryFindNodeIndexForStartOffset(this.contextNode.children(), this.nextTokenSpan.Span.startPosition());
+ if(nodeIndex < 0) {
+ return false;
+ }
+ sibling = this.contextNode.children().get(nodeIndex);
+ for(var i = nodeIndex - 1; i >= 0; --i) {
+ var child = this.contextNode.children().get(i);
+ if(child.AuthorNode.Details.EndOffset == this.tokenSpan.Span.endPosition()) {
+ current = child;
+ break;
+ }
+ }
+ if(current == null) {
+ return false;
+ }
+ var startLine = this.snapshot.GetLineNumberFromPosition(current.AuthorNode.Details.EndOffset);
+ var endLine = this.snapshot.GetLineNumberFromPosition(sibling.AuthorNode.Details.StartOffset);
+ return startLine == endLine;
+ };
+ return FormattingContext;
+ })();
+ Formatting.FormattingContext = FormattingContext;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var FormattingManager = (function () {
+ function FormattingManager(scriptSyntaxAST, rulesProvider, editorOptions) {
+ this.scriptSyntaxAST = scriptSyntaxAST;
+ this.rulesProvider = rulesProvider;
+ this.editorOptions = editorOptions;
+ this.logger = new TypeScript.LoggerAdapter(this.scriptSyntaxAST.getLogger());
+ this.sourceText = this.scriptSyntaxAST.getSourceText();
+ this.snapshot = new Formatting.TextSnapshot(this.scriptSyntaxAST.getScript(), this.sourceText);
+ this.fileAuthoringProxy = new Formatting.FileAuthoringProxy(this.scriptSyntaxAST);
+ this.tokenKindMap = Formatting.AuthorTokenKindMap.getInstance();
+ }
+ FormattingManager.prototype.FormatSelection = function (minChar, limChar) {
+ var span = new Formatting.SnapshotSpan(this.snapshot, Formatting.Span.FromBounds(minChar, limChar));
+ return this.Format(span, Formatting.FormattingRequestKind.FormatSelection, function (a, b) {
+ return true;
+ });
+ };
+ FormattingManager.prototype.FormatDocument = function (minChar, limChar) {
+ var span = new Formatting.SnapshotSpan(this.snapshot, Formatting.Span.FromBounds(minChar, limChar));
+ return this.Format(span, Formatting.FormattingRequestKind.FormatDocument, function (a, b) {
+ return true;
+ });
+ };
+ FormattingManager.prototype.FormatOnPaste = function (minChar, limChar) {
+ var span = new Formatting.SnapshotSpan(this.snapshot, Formatting.Span.FromBounds(minChar, limChar));
+ return this.Format(span, Formatting.FormattingRequestKind.FormatOnPaste, function (a, b) {
+ return true;
+ });
+ };
+ FormattingManager.prototype.CanFormatSpan = function (span) {
+ return true;
+ };
+ FormattingManager.prototype.FormatOnSemicolon = function (caretPosition) {
+ var _this = this;
+ var caret = new Formatting.SnapshotPoint(this.snapshot, caretPosition);
+ var semicolonPoint = caret.Add(-1);
+ var mappedPoint = this.MapDownSnapshotPoint(semicolonPoint);
+ if(mappedPoint !== null) {
+ var span = this.FindStatementSpan(mappedPoint, Formatting.FormattingRequestKind.FormatOnSemicolon);
+ if(span != null) {
+ return this.Format(span, Formatting.FormattingRequestKind.FormatOnSemicolon, function (tokens, requestKind) {
+ return !_this.IsInsideStringLiteralOrComment(mappedPoint, tokens);
+ });
+ }
+ }
+ return [];
+ };
+ FormattingManager.prototype.FormatOnClosingCurlyBrace = function (caretPosition) {
+ var _this = this;
+ var caret = new Formatting.SnapshotPoint(this.snapshot, caretPosition);
+ var closeBracePoint = caret.Add(-1);
+ var mappedPoint = this.MapDownSnapshotPoint(closeBracePoint);
+ if(mappedPoint !== null) {
+ var span = this.FindMatchingBlockSpan(mappedPoint, Formatting.FormattingRequestKind.FormatOnClosingCurlyBrace);
+ if(span != null) {
+ return this.Format(span, Formatting.FormattingRequestKind.FormatOnClosingCurlyBrace, function (tokens, requestKind) {
+ return !_this.IsInsideStringLiteralOrComment(mappedPoint, tokens);
+ });
+ }
+ }
+ return [];
+ };
+ FormattingManager.prototype.FormatOnEnter = function (caretPosition) {
+ var _this = this;
+ var lineNumber = this.snapshot.GetLineNumberFromPosition(caretPosition);
+ if(lineNumber > 0) {
+ var prevLine = this.snapshot.GetLineFromLineNumber(lineNumber - 1);
+ var currentLine = this.snapshot.GetLineFromLineNumber(lineNumber);
+ var span = new Formatting.SnapshotSpan(this.snapshot, Formatting.Span.FromBounds(prevLine.startPosition(), currentLine.endPosition()));
+ if(span != null) {
+ var caret = new Formatting.SnapshotPoint(this.snapshot, caretPosition);
+ var mappedPoint = this.MapDownSnapshotPoint(caret);
+ return this.Format(span, Formatting.FormattingRequestKind.FormatOnEnter, function (tokens, requestKind) {
+ return !_this.IsInsideStringLiteralOrComment(mappedPoint, tokens);
+ });
+ }
+ }
+ return [];
+ };
+ FormattingManager.prototype.FindMatchingBlockSpan = function (bracePoint, formattingRequestKind) {
+ var authoringProxy = this.fileAuthoringProxy;
+ var matchingBlockTask = new Formatting.MatchingBlockFinderTask(bracePoint, authoringProxy);
+ var blockSpan = matchingBlockTask.Run();
+ if(blockSpan !== null) {
+ return new Formatting.SnapshotSpan(bracePoint.snapshot, blockSpan);
+ } else {
+ return null;
+ }
+ };
+ FormattingManager.prototype.FindStatementSpan = function (semicolonPoint, formattingRequestKind) {
+ var authoringProxy = this.fileAuthoringProxy;
+ var statementFinderTask = new Formatting.StatementFinderTask(this.logger, semicolonPoint, authoringProxy);
+ statementFinderTask.Run();
+ if(statementFinderTask.BlockSpan != null) {
+ return new Formatting.SnapshotSpan(semicolonPoint.snapshot, statementFinderTask.BlockSpan);
+ } else {
+ return null;
+ }
+ };
+ FormattingManager.prototype.MapDownSnapshotSpan = function (snapshotSpan) {
+ return snapshotSpan;
+ };
+ FormattingManager.prototype.MapDownSnapshotPoint = function (snapshotPoint) {
+ return snapshotPoint;
+ };
+ FormattingManager.prototype.GetTokens = function (span) {
+ return Formatting.getTokensInSpan(this.logger, this.scriptSyntaxAST, this.tokenKindMap, span);
+ };
+ FormattingManager.prototype.IsInsideStringLiteralOrComment = function (point, tokens) {
+ if(point !== null) {
+ var span = new Formatting.Span(point.position, 1);
+ for(var i = 0; i < tokens.count(); i++) {
+ var token = tokens.get(i);
+ if(token.Span.OverlapsWith(span)) {
+ return token.Token == Formatting.AuthorTokenKind.atkString || token.Token == Formatting.AuthorTokenKind.atkComment;
+ }
+ }
+ }
+ return false;
+ };
+ FormattingManager.prototype.Format = function (span, formattingRequestKind, prerequisiteTokenTest) {
+ var _this = this;
+ if(span.IsEmpty() || !this.CanFormatSpan(span)) {
+ return [];
+ }
+ var scriptHasErrors = false;
+ if(scriptHasErrors) {
+ return [];
+ }
+ var startLinePoint = span.start().GetContainingLine().start();
+ span = new Formatting.SnapshotSpan(startLinePoint.snapshot, Formatting.Span.FromBounds(startLinePoint.position, span.endPosition()));
+ var tokens = TypeScript.timeFunction(this.logger, "FormattingManager: GetTokens()", function () {
+ return _this.GetTokens(span);
+ });
+ if(prerequisiteTokenTest != null && !prerequisiteTokenTest(tokens, formattingRequestKind)) {
+ return [];
+ }
+ var languageHostIndentation = null;
+ var editorOptions = this.editorOptions;
+ var formattingTask = new Formatting.FormattingTask(this.logger, this.snapshot, span, tokens, this.fileAuthoringProxy, this.rulesProvider, editorOptions, languageHostIndentation, scriptHasErrors, formattingRequestKind);
+ formattingTask.Run();
+ var result = [];
+ formattingTask.EditCommands.foreach(function (item) {
+ var edit = new Services.TextEdit(item.position, item.position + item.Length, item.replaceWith);
+ result.push(edit);
+ });
+ return result;
+ };
+ return FormattingManager;
+ })();
+ Formatting.FormattingManager = FormattingManager;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ (function (FormattingRequestKind) {
+ FormattingRequestKind._map = [];
+ FormattingRequestKind._map[0] = "FormatDocument";
+ FormattingRequestKind.FormatDocument = 0;
+ FormattingRequestKind._map[1] = "FormatSelection";
+ FormattingRequestKind.FormatSelection = 1;
+ FormattingRequestKind._map[2] = "FormatOnEnter";
+ FormattingRequestKind.FormatOnEnter = 2;
+ FormattingRequestKind._map[3] = "FormatOnSemicolon";
+ FormattingRequestKind.FormatOnSemicolon = 3;
+ FormattingRequestKind._map[4] = "FormatOnClosingCurlyBrace";
+ FormattingRequestKind.FormatOnClosingCurlyBrace = 4;
+ FormattingRequestKind._map[5] = "FormatOnPaste";
+ FormattingRequestKind.FormatOnPaste = 5;
+ })(Formatting.FormattingRequestKind || (Formatting.FormattingRequestKind = {}));
+ var FormattingRequestKind = Formatting.FormattingRequestKind;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var FormattingTask = (function () {
+ function FormattingTask(logger, Snapshot, span, tokens, fileAuthoringProxy, rulesProvider, editorOptions, languageHostIndentation, scriptHasErrors, formattingRequestKind) {
+ this.logger = logger;
+ this.Snapshot = Snapshot;
+ this.span = span;
+ this.tokens = tokens;
+ this.fileAuthoringProxy = fileAuthoringProxy;
+ this.rulesProvider = rulesProvider;
+ this.editorOptions = editorOptions;
+ this.languageHostIndentation = languageHostIndentation;
+ this.scriptHasErrors = scriptHasErrors;
+ this.formattingRequestKind = formattingRequestKind;
+ this.snapshotSpan = this.span;
+ this.tokenTags = this.tokens;
+ this.EditCommands = new Formatting.List_TextEditInfo();
+ }
+ FormattingTask.prototype.Run = function () {
+ var _this = this;
+ if(this.tokenTags.count() == 0) {
+ return;
+ }
+ var tree = TypeScript.timeFunction(this.logger, "FormattingTask: new ParseTree()", function () {
+ return new Formatting.ParseTree(_this.fileAuthoringProxy, _this.snapshotSpan.span, _this.tokenTags, false);
+ });
+ if(tree.Root == null) {
+ return;
+ }
+ TypeScript.timeFunction(this.logger, "FormattingTask: FillIndentationLevels()", function () {
+ Formatting.IndentationEdgeFinder.FillIndentationLevels(tree.Root);
+ });
+ TypeScript.timeFunction(this.logger, "FormattingTask: Format()", function () {
+ _this.Format(tree);
+ });
+ };
+ FormattingTask.prototype.Format = function (tree) {
+ var _this = this;
+ var tokenIndex = 0;
+ var token1Line = 0;
+ var currentLineNumber = -1;
+ var context = tree.Root;
+ Formatting.ParseTree.DumpTree(this.logger, tree.Root);
+ var sameLineIndent = false;
+ var t1 = this.tokenTags.get(0);
+ token1Line = t1.lineNumber();
+ var indenter = new Formatting.Indenter(this.logger, tree, this.Snapshot, this.languageHostIndentation, this.editorOptions, t1, false);
+ if(!this.scriptHasErrors) {
+ this.TrimWhitespaceInLineRange(t1, this.Snapshot.GetLineNumberFromPosition(this.snapshotSpan.startPosition()), token1Line - 1);
+ }
+ if(this.tokenTags.count() == 1) {
+ context = Formatting.ParseTree.FindCommonParentNode(t1.Span.span, t1.Span.span, context);
+ }
+ var formattingContext = new Formatting.FormattingContext(this.fileAuthoringProxy, this.Snapshot, this.tokenTags, this.formattingRequestKind);
+ for(tokenIndex = 1; tokenIndex < this.tokenTags.count(); tokenIndex++) {
+ if(this.logger.information()) {
+ this.logger.log("Processing token #" + tokenIndex + ": tokenId=" + (TypeScript.TokenID)._map[t1.tokenID] + ", span=[" + t1.Span.startPosition() + "," + t1.Span.endPosition() + "]");
+ }
+ var t2 = this.tokenTags.get(tokenIndex);
+ var token2Line = t2.lineNumber();
+ context = Formatting.ParseTree.FindCommonParentNode(t1.Span.span, t2.Span.span, context);
+ if(context.TokenTagIndex == null && context.AuthorNode.Details.StartOffset == t1.Span.span.start()) {
+ context.TokenTagIndex = tokenIndex - 1;
+ }
+ if(token1Line != currentLineNumber) {
+ var node = this.FindTokenNode(t1.Span.span, context);
+ var edits = indenter.GetIndentationEdits(t1, t2, node, sameLineIndent);
+ for(var i = 0; i < edits.count(); i++) {
+ this.EditCommands.add(edits.get(i));
+ }
+ currentLineNumber = token1Line;
+ sameLineIndent = false;
+ }
+ if(t1.Token == Formatting.AuthorTokenKind.atkComment || t1.Token == Formatting.AuthorTokenKind.atkString) {
+ currentLineNumber = this.Snapshot.GetLineNumberFromPosition(t1.Span.endPosition());
+ }
+ if(this.logger.information()) {
+ this.logger.log("Context node: " + context.toString());
+ }
+ if(!this.scriptHasErrors) {
+ formattingContext.setContext(context, t1, t2);
+ var rule = this.rulesProvider.getRulesMap().GetRule(formattingContext);
+ if(rule != null) {
+ this.GetRuleEdits(rule, t1, t2).foreach(function (edit) {
+ _this.EditCommands.add(edit);
+ });
+ if((rule.Operation.Action == Formatting.RuleAction.Space || rule.Operation.Action == Formatting.RuleAction.Delete) && token1Line != token2Line) {
+ var indent = indenter.GetLineIndentationForOffset(t1.Span.startPosition());
+ indenter.RegisterIndentation2(t2.Span.startPosition(), indent);
+ currentLineNumber = token2Line;
+ }
+ if(rule.Operation.Action == Formatting.RuleAction.NewLine && token1Line == token2Line) {
+ currentLineNumber = token2Line - 1;
+ sameLineIndent = true;
+ }
+ }
+ if(token1Line != token2Line) {
+ this.TrimWhitespaceInLineRange(t1, token1Line, token2Line - 1);
+ }
+ }
+ t1 = t2;
+ token1Line = token2Line;
+ }
+ if(token1Line != currentLineNumber) {
+ context = Formatting.ParseTree.FindCommonParentNode(t1.Span.span, t1.Span.span, context);
+ indenter.GetIndentationEdits(t1, null, context, sameLineIndent).foreach(function (edit) {
+ _this.EditCommands.add(edit);
+ });
+ }
+ if(!this.scriptHasErrors) {
+ var projectionEndLineSet = this.GetProjectionLineEndPositionSet();
+ if(!projectionEndLineSet.Contains(token1Line)) {
+ this.TrimWhitespace(t1);
+ var endlineNumber = this.Snapshot.GetLineNumberFromPosition(this.snapshotSpan.endPosition());
+ if(projectionEndLineSet.Contains(endlineNumber)) {
+ endlineNumber--;
+ }
+ this.TrimWhitespaceInLineRange(t1, token1Line + 1, endlineNumber);
+ }
+ }
+ };
+ FormattingTask.prototype.GetProjectionEndLines = function () {
+ var result = new Formatting.List_ITextSnapshotLine();
+ return result;
+ };
+ FormattingTask.prototype.GetProjectionLineEndPositionSet = function () {
+ var projectionEndLineSet = new Formatting.HashSet_int();
+ this.GetProjectionEndLines().foreach(function (line) {
+ if(!projectionEndLineSet.Contains(line.lineNumber())) {
+ projectionEndLineSet.Add(line.lineNumber());
+ }
+ });
+ return projectionEndLineSet;
+ };
+ FormattingTask.prototype.TrimWhitespaceInLineRange = function (token, startLine, endLine) {
+ for(var lineNumber = startLine; lineNumber <= endLine; ++lineNumber) {
+ var line = this.Snapshot.GetLineFromLineNumber(lineNumber);
+ this.TrimWhitespace2(token, line);
+ }
+ };
+ FormattingTask.prototype.TrimWhitespace = function (token) {
+ var line = this.Snapshot.GetLineFromPosition(token.Span.startPosition());
+ this.TrimWhitespace2(token, line);
+ };
+ FormattingTask.prototype.TrimWhitespace2 = function (token, line) {
+ if(token.Token == Formatting.AuthorTokenKind.atkComment && token.Span.startPosition() <= line.endPosition() && token.Span.endPosition() >= line.endPosition()) {
+ return;
+ }
+ var text = line.getText();
+ var index = 0;
+ for(index = text.length - 1; index >= 0; --index) {
+ if(!Formatting.EditorUtilities.IsWhitespace(text.charCodeAt(index))) {
+ break;
+ }
+ }
+ ++index;
+ if(index < text.length) {
+ var edit = new Formatting.TextEditInfo(line.startPosition() + index, line.length() - index, "");
+ if(this.logger.information()) {
+ this.logger.log("TrimWhiteSpace2()");
+ this.logger.log("edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" + TypeScript.stringToLiteral(edit.replaceWith, 30) + "\"");
+ }
+ this.EditCommands.add(edit);
+ }
+ };
+ FormattingTask.prototype.GetRuleEdits = function (rule, t1, t2) {
+ if(this.logger.information()) {
+ this.logger.log("GetRuleEdits(" + this.rulesProvider.getRuleName(rule) + ", " + "t1=[" + t1.Span.startPosition() + "," + t1.Span.endPosition() + "], " + "t2=[" + t2.Span.startPosition() + "," + t2.Span.endPosition() + "]" + ")");
+ }
+ var result = this.GetRuleEditsWorker(rule, t1, t2);
+ if(this.logger.information()) {
+ for(var i = 0; i < result.count(); i++) {
+ var edit = result.get(i);
+ this.logger.log("edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" + TypeScript.stringToLiteral(edit.replaceWith, 30) + "\"");
+ }
+ }
+ return result;
+ };
+ FormattingTask.prototype.GetRuleEditsWorker = function (rule, t1, t2) {
+ var emptyResult = new Formatting.List_TextEditInfo();
+ if(rule.Operation.Action == Formatting.RuleAction.Ignore) {
+ return emptyResult;
+ }
+ var betweenSpan;
+ switch(rule.Operation.Action) {
+ case Formatting.RuleAction.Delete:
+ {
+ betweenSpan = new Formatting.Span(t1.Span.endPosition(), t2.Span.startPosition() - t1.Span.endPosition());
+ if(betweenSpan.length() > 0) {
+ return new Formatting.List_TextEditInfo(new Formatting.TextEditInfo(betweenSpan.start(), betweenSpan.length(), ""));
+ }
+ }
+ break;
+ case Formatting.RuleAction.NewLine:
+ {
+ if(rule.Flag == Formatting.RuleFlags.CanDeleteNewLines) {
+ betweenSpan = new Formatting.Span(t1.Span.endPosition(), t2.Span.startPosition() - t1.Span.endPosition());
+ } else {
+ var lengthBetween;
+ if(t1.lineNumber() == t2.lineNumber()) {
+ lengthBetween = t2.Span.startPosition() - t1.Span.endPosition();
+ } else {
+ lengthBetween = t1.Span.end().GetContainingLine().endIncludingLineBreakPosition() - t1.Span.endPosition();
+ }
+ betweenSpan = new Formatting.Span(t1.Span.endPosition(), Formatting.Math.Max(0, lengthBetween));
+ }
+ var doEdit = false;
+ var betweenText = this.Snapshot.GetText(betweenSpan);
+ var lineFeedLoc = Formatting.StringUtils.IndexOf(betweenText, this.editorOptions.NewLineCharacter);
+ if(lineFeedLoc < 0) {
+ doEdit = true;
+ } else {
+ lineFeedLoc = Formatting.StringUtils.IndexOf(betweenText, this.editorOptions.NewLineCharacter, lineFeedLoc + 1);
+ if(lineFeedLoc >= 0) {
+ doEdit = true;
+ }
+ }
+ if(doEdit) {
+ return new Formatting.List_TextEditInfo(new Formatting.TextEditInfo(betweenSpan.start(), betweenSpan.length(), this.editorOptions.NewLineCharacter));
+ }
+ }
+ break;
+ case Formatting.RuleAction.Space:
+ {
+ if(rule.Flag == Formatting.RuleFlags.CanDeleteNewLines) {
+ betweenSpan = new Formatting.Span(t1.Span.endPosition(), t2.Span.startPosition() - t1.Span.endPosition());
+ } else {
+ var lengthBetween;
+ if(t1.lineNumber() == t2.lineNumber()) {
+ lengthBetween = t2.Span.startPosition() - t1.Span.endPosition();
+ } else {
+ lengthBetween = t1.Span.end().GetContainingLine().endPosition() - t1.Span.endPosition();
+ }
+ betweenSpan = new Formatting.Span(t1.Span.endPosition(), Formatting.Math.Max(0, lengthBetween));
+ }
+ if(betweenSpan.length() > 1 || this.Snapshot.GetText(betweenSpan) != " ") {
+ return new Formatting.List_TextEditInfo(new Formatting.TextEditInfo(betweenSpan.start(), betweenSpan.length(), " "));
+ }
+ }
+ break;
+ }
+ return emptyResult;
+ };
+ FormattingTask.prototype.FindTokenNode = function (span, helperNode) {
+ if(helperNode.CoverSpan(span)) {
+ if(helperNode.children() != null) {
+ var child = Formatting.ParseNodeExtensions.TryFindNodeForSpan(helperNode.children(), span);
+ if(child != null) {
+ return this.FindTokenNode(span, child);
+ }
+ }
+ return helperNode;
+ } else {
+ if(helperNode.Parent == null) {
+ return helperNode;
+ } else {
+ return this.FindTokenNode(span, helperNode.Parent);
+ }
+ }
+ };
+ return FormattingTask;
+ })();
+ Formatting.FormattingTask = FormattingTask;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var IndentationBag = (function () {
+ function IndentationBag(snapshot) {
+ this.snapshot = snapshot;
+ this.indentationEdits = new Formatting.Dictionary_int_List_IndentationEditInfo();
+ }
+ IndentationBag.prototype.AddIndent = function (edit) {
+ var line = this.snapshot.GetLineNumberFromPosition(edit.Position());
+ var lineIndents = this.indentationEdits.GetValue(line);
+ if(lineIndents === null) {
+ lineIndents = new Formatting.List_IndentationEditInfo();
+ this.indentationEdits.Add(line, lineIndents);
+ }
+ lineIndents.add(edit);
+ };
+ IndentationBag.prototype.FindIndent = function (position) {
+ var line = this.snapshot.GetLineNumberFromPosition(position);
+ var lineIndents = this.indentationEdits.GetValue(line);
+ if(lineIndents !== null) {
+ for(var i = lineIndents.count() - 1; i >= 0; i--) {
+ if(position >= lineIndents.get(i).Position()) {
+ return lineIndents.get(i);
+ }
+ }
+ }
+ return null;
+ };
+ return IndentationBag;
+ })();
+ Formatting.IndentationBag = IndentationBag;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var IndentationEdgeFinder = (function () {
+ function IndentationEdgeFinder() { }
+ IndentationEdgeFinder.FillIndentationLevels = function FillIndentationLevels(node) {
+ var nodeStack = new Formatting.Stack_ParseNode();
+ nodeStack.Push(node);
+ while(nodeStack.Count() > 0) {
+ IndentationEdgeFinder.FillIndentationLevels2(nodeStack.Pop(), nodeStack);
+ }
+ };
+ IndentationEdgeFinder.FillBodyIndentation = function FillBodyIndentation(node, nextNodesToVisit) {
+ node.IsIndentationOverrideEdge = true;
+ node.ChildrenIndentationDelta = 1;
+ Formatting.ParseNodeExtensions.ForAllChildren(Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneBody), function (child) {
+ if(child.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkEndCode) {
+ child.IndentationDelta = 1;
+ }
+ nextNodesToVisit.Push(child);
+ });
+ };
+ IndentationEdgeFinder.FillIndentationLevels2 = function FillIndentationLevels2(node, nextNodesToVisit) {
+ switch(node.AuthorNode.Details.nodeType) {
+ case TypeScript.NodeType.ModuleDeclaration:
+ case TypeScript.NodeType.ClassDeclaration:
+ case TypeScript.NodeType.InterfaceDeclaration:
+ IndentationEdgeFinder.FillBodyIndentation(node, nextNodesToVisit);
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ nextNodesToVisit.Push(child);
+ });
+ return;
+ case TypeScript.NodeType.ImportDeclaration:
+ node.ChildrenIndentationDelta = 1;
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ nextNodesToVisit.Push(child);
+ });
+ return;
+ }
+ switch(node.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkProg:
+ {
+ node.IndentationDelta = 0;
+ node.ChildrenIndentationDelta = 0;
+ var child = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneBody);
+ Formatting.ParseNodeExtensions.ForAllChildren(child, function (child) {
+ child.IndentationDelta = 0;
+ child.ChildrenIndentationDelta = 0;
+ nextNodesToVisit.Push(child);
+ });
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkBlock:
+ {
+ if((node.AuthorNode.Details.Flags & Formatting.AuthorParseNodeFlags.apnfSyntheticNode) != Formatting.AuthorParseNodeFlags.apnfSyntheticNode) {
+ IndentationEdgeFinder.FillIndentationEdgesForBlock(node, 1);
+ } else {
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ IndentationEdgeFinder.FillIndentationLevels(child);
+ });
+ node.IndentationDelta = null;
+ node.ChildrenIndentationDelta = null;
+ }
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkTryCatch:
+ case Formatting.AuthorParseNodeKind.apnkTryFinally:
+ {
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ IndentationEdgeFinder.FillIndentationLevels(child);
+ });
+ node.IndentationDelta = null;
+ node.ChildrenIndentationDelta = null;
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkFncDecl:
+ {
+ IndentationEdgeFinder.FillBodyIndentation(node, nextNodesToVisit);
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ {
+ node.ChildrenIndentationDelta = 1;
+ var col = Formatting.ParseNodeExtensions.GetChildren(node).Where(function (c) {
+ return c.AuthorNode.EdgeLabel == Formatting.AuthorParseNodeEdge.apneCase || c.AuthorNode.EdgeLabel == Formatting.AuthorParseNodeEdge.apneDefaultCase;
+ });
+ col.foreach(function (caseNode) {
+ caseNode.IndentationDelta = 1;
+ caseNode.ChildrenIndentationDelta = 1;
+ nextNodesToVisit.Push(caseNode);
+ });
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkCase:
+ case Formatting.AuthorParseNodeKind.apnkDefaultCase:
+ {
+ var child = Formatting.ParseNodeExtensions.FindChildWithEdge(Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneBody), Formatting.AuthorParseNodeEdge.apneBlockBody);
+ if(child != null) {
+ if(child.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkList) {
+ Formatting.ParseNodeExtensions.ForAllChildren(child, function (grandChild) {
+ grandChild.IndentationDelta = 1;
+ nextNodesToVisit.Push(grandChild);
+ });
+ } else if(child.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock) {
+ child.IndentationDelta = 1;
+ IndentationEdgeFinder.FillIndentationEdgesForBlock(child, 1);
+ } else {
+ child.IndentationDelta = 1;
+ nextNodesToVisit.Push(child);
+ }
+ }
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkIf:
+ {
+ node.ChildrenIndentationDelta = 1;
+ var thenChild = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneThen);
+ IndentationEdgeFinder.FillIndentationEdgesForBlockOrNot(thenChild, 1);
+ var elseChild = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneElse);
+ IndentationEdgeFinder.FillIndentationEdgesForBlockOrNot(elseChild, 1);
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkWhile:
+ case Formatting.AuthorParseNodeKind.apnkWith:
+ case Formatting.AuthorParseNodeKind.apnkDoWhile:
+ {
+ node.ChildrenIndentationDelta = 1;
+ var child = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneBody);
+ IndentationEdgeFinder.FillIndentationEdgesForBlockOrNot(child, 1);
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkObject:
+ {
+ node.IsIndentationOverrideEdge = true;
+ node.ChildrenIndentationDelta = 1;
+ var members = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneMembers);
+ if(members != null) {
+ if(members.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkList) {
+ Formatting.ParseNodeExtensions.ForAllChildren(members, function (grandChild) {
+ grandChild.ChildrenIndentationDelta = 1;
+ grandChild.IndentationDelta = 1;
+ nextNodesToVisit.Push(grandChild);
+ });
+ } else {
+ members.ChildrenIndentationDelta = 1;
+ members.IndentationDelta = 1;
+ nextNodesToVisit.Push(members);
+ }
+ }
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkArray:
+ {
+ node.IsIndentationOverrideEdge = true;
+ node.ChildrenIndentationDelta = 1;
+ var elements = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneElements);
+ if(elements != null) {
+ if(elements.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkList) {
+ Formatting.ParseNodeExtensions.ForAllChildren(elements, function (grandChild) {
+ grandChild.IsIndentationOverrideEdge = true;
+ nextNodesToVisit.Push(grandChild);
+ });
+ } else {
+ elements.IsIndentationOverrideEdge = true;
+ nextNodesToVisit.Push(elements);
+ }
+ }
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkTry:
+ case Formatting.AuthorParseNodeKind.apnkCatch:
+ case Formatting.AuthorParseNodeKind.apnkFinally:
+ {
+ node.ChildrenIndentationDelta = 1;
+ var body = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneBody);
+ if(body == null || (body != null && body.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkTryCatch && body.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkTryFinally)) {
+ var parent = node.Parent;
+ while(parent != null) {
+ if((parent.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkTryCatch || parent.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkTryFinally) && parent.IndentationDelta != null) {
+ node.IndentationDelta = parent.IndentationDelta;
+ break;
+ }
+ parent = parent.Parent;
+ }
+ }
+ if(body != null && body.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock) {
+ IndentationEdgeFinder.FillIndentationEdgesForBlock(body, 1);
+ } else {
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ nextNodesToVisit.Push(child);
+ });
+ }
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkAsg:
+ case Formatting.AuthorParseNodeKind.apnkAsgAdd:
+ case Formatting.AuthorParseNodeKind.apnkAsgSub:
+ case Formatting.AuthorParseNodeKind.apnkAsgMul:
+ case Formatting.AuthorParseNodeKind.apnkAsgDiv:
+ case Formatting.AuthorParseNodeKind.apnkAsgMod:
+ case Formatting.AuthorParseNodeKind.apnkAsgAnd:
+ case Formatting.AuthorParseNodeKind.apnkAsgXor:
+ case Formatting.AuthorParseNodeKind.apnkAsgOr:
+ case Formatting.AuthorParseNodeKind.apnkAsgLsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRs2:
+ case Formatting.AuthorParseNodeKind.apnkVarDecl:
+ case Formatting.AuthorParseNodeKind.apnkVarDeclList:
+ case Formatting.AuthorParseNodeKind.apnkCall:
+ case Formatting.AuthorParseNodeKind.apnkNew:
+ case Formatting.AuthorParseNodeKind.apnkDelete:
+ case Formatting.AuthorParseNodeKind.apnkReturn:
+ case Formatting.AuthorParseNodeKind.apnkDot:
+ case Formatting.AuthorParseNodeKind.apnkIndex:
+ {
+ if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkVarDecl && node.Parent != null && node.Parent.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkVarDeclList) {
+ } else {
+ node.ChildrenIndentationDelta = 1;
+ }
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ nextNodesToVisit.Push(child);
+ });
+ }
+ break;
+ default:
+ {
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ nextNodesToVisit.Push(child);
+ });
+ }
+ break;
+ }
+ };
+ IndentationEdgeFinder.FillIndentationEdgesForBlockOrNot = function FillIndentationEdgesForBlockOrNot(node, childrenLevel) {
+ if(node == null) {
+ return;
+ }
+ node.ChildrenIndentationDelta = childrenLevel;
+ if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock) {
+ IndentationEdgeFinder.FillIndentationEdgesForBlock(node, childrenLevel);
+ } else {
+ node.IndentationDelta = childrenLevel;
+ IndentationEdgeFinder.FillIndentationLevels(node);
+ }
+ };
+ IndentationEdgeFinder.FillIndentationEdgesForBlock = function FillIndentationEdgesForBlock(node, childrenLevel) {
+ if(node == null) {
+ return;
+ }
+ Formatting.Debug.Assert(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock, "Expecting a node of kind block.");
+ if((node.AuthorNode.Details.Flags & Formatting.AuthorParseNodeFlags.apnfSyntheticNode) != Formatting.AuthorParseNodeFlags.apnfSyntheticNode) {
+ node.ChildrenIndentationDelta = childrenLevel;
+ }
+ var child = Formatting.FirstOrDefault(Formatting.ParseNodeExtensions.GetChildren(node), function () {
+ return true;
+ });
+ if(child != null) {
+ if(child.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkList) {
+ Formatting.ParseNodeExtensions.ForAllChildren(child, function (grandChild) {
+ grandChild.IndentationDelta = node.ChildrenIndentationDelta;
+ IndentationEdgeFinder.FillIndentationLevels(grandChild);
+ });
+ } else {
+ child.IndentationDelta = node.ChildrenIndentationDelta;
+ IndentationEdgeFinder.FillIndentationLevels(child);
+ }
+ }
+ };
+ return IndentationEdgeFinder;
+ })();
+ Formatting.IndentationEdgeFinder = IndentationEdgeFinder;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var IndentationEditInfo = (function () {
+ function IndentationEditInfo(textEditInfo) {
+ this.textEditInfo = textEditInfo;
+ this.OrigIndentPosition = this.textEditInfo.Position;
+ }
+ IndentationEditInfo.prototype.Position = function () {
+ {
+ return this.textEditInfo.Position;
+ }
+ };
+ IndentationEditInfo.prototype.Indentation = function () {
+ {
+ return this.textEditInfo.ReplaceWith;
+ }
+ };
+ IndentationEditInfo.prototype.OrigIndentLength = function () {
+ {
+ return this.textEditInfo.Length;
+ }
+ };
+ IndentationEditInfo.create1 = function create1(textEditInfo) {
+ return new IndentationEditInfo(textEditInfo);
+ };
+ IndentationEditInfo.create2 = function create2(position, indentString, origPosition, origIndentLength) {
+ var textEditInfo = new Formatting.TextEditInfo(position, origIndentLength, indentString);
+ var result = new IndentationEditInfo(textEditInfo);
+ result.OrigIndentPosition = origPosition;
+ return result;
+ };
+ return IndentationEditInfo;
+ })();
+ Formatting.IndentationEditInfo = IndentationEditInfo;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var IndentationInfo = (function () {
+ function IndentationInfo(Prefix, Level) {
+ if (typeof Prefix === "undefined") { Prefix = null; }
+ if (typeof Level === "undefined") { Level = 0; }
+ this.Prefix = Prefix;
+ this.Level = Level;
+ }
+ return IndentationInfo;
+ })();
+ Formatting.IndentationInfo = IndentationInfo;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var Indenter = (function () {
+ function Indenter(logger, tree, snapshot, languageHostIndentation, editorOptions, firstToken, smartIndent) {
+ this.logger = logger;
+ this.tree = tree;
+ this.snapshot = snapshot;
+ this.languageHostIndentation = languageHostIndentation;
+ this.editorOptions = editorOptions;
+ this.firstToken = firstToken;
+ this.smartIndent = smartIndent;
+ this.indentationBag = new Formatting.IndentationBag(this.snapshot);
+ this.scriptBlockBeginLineNumber = -1;
+ this.offsetIndentationDeltas = new Formatting.Dictionary_int_int();
+ this.tree.Root.SetIndentationOverride("");
+ this.ApplyScriptBlockIndentation(this.languageHostIndentation, this.tree);
+ this.FillInheritedIndentation(this.tree);
+ }
+ Indenter.prototype.GetIndentationEdits = function (token, nextToken, node, sameLineIndent) {
+ if(this.logger.information()) {
+ this.logger.log("GetIndentationEdits(" + "t1=[" + token.Span.startPosition() + "," + token.Span.endPosition() + "], " + "t2=[" + (nextToken == null ? "null" : (nextToken.Span.startPosition() + "," + nextToken.Span.endPosition())) + "]" + ")");
+ }
+ var result = this.GetIndentationEditsWorker(token, nextToken, node, sameLineIndent);
+ if(this.logger.information()) {
+ for(var i = 0; i < result.count(); i++) {
+ var edit = result.get(i);
+ this.logger.log("edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" + TypeScript.stringToLiteral(edit.replaceWith, 30) + "\"");
+ }
+ }
+ return result;
+ };
+ Indenter.prototype.GetIndentationEditsWorker = function (token, nextToken, node, sameLineIndent) {
+ var result = new Formatting.List_TextEditInfo();
+ var indentationInfo = null;
+ this.AdjustStartOffsetIfNeeded(token, node);
+ if(this.scriptBlockBeginLineNumber == token.lineNumber()) {
+ return result;
+ }
+ if(!sameLineIndent && this.IsMultiLineString(token)) {
+ return result;
+ }
+ indentationInfo = this.GetSpecialCaseIndentation(token, node);
+ if(indentationInfo == null) {
+ while(!node.CanIndent() && node.Parent != null && token.Span.span.start() == node.Parent.AuthorNode.Details.StartOffset) {
+ node = node.Parent;
+ }
+ if(node.CanIndent() && token.Span.span.start() == node.AuthorNode.Details.StartOffset) {
+ indentationInfo = node.GetEffectiveIndentation(this);
+ } else {
+ if(token.Token == Formatting.AuthorTokenKind.atkIdentifier && nextToken != null && nextToken.Token == Formatting.AuthorTokenKind.atkColon) {
+ indentationInfo = node.GetEffectiveChildrenIndentation(this);
+ } else {
+ indentationInfo = this.ApplyIndentationDeltaFromParent(token, node);
+ }
+ }
+ }
+ if(indentationInfo != null) {
+ var edit = this.GetIndentEdit(indentationInfo, token.Span.startPosition(), sameLineIndent);
+ if(edit != null) {
+ this.RegisterIndentation(edit, sameLineIndent);
+ result.add(edit);
+ if(token.Token == Formatting.AuthorTokenKind.atkComment) {
+ var commentEdits = this.GetCommentIndentationEdits(token);
+ commentEdits.foreach(function (item) {
+ result.add(item);
+ });
+ }
+ }
+ }
+ return result;
+ };
+ Indenter.prototype.GetCommentIndentationEdits = function (token) {
+ var result = new Formatting.List_TextEditInfo();
+ if(token.Token != Formatting.AuthorTokenKind.atkComment) {
+ return result;
+ }
+ var commentLastLineNumber = this.snapshot.GetLineNumberFromPosition(token.Span.endPosition());
+ if(token.lineNumber() == commentLastLineNumber) {
+ return result;
+ }
+ var commentFirstLineIndentationDelta = this.GetIndentationDelta(token.Span.startPosition(), null);
+ if(commentFirstLineIndentationDelta != undefined) {
+ for(var line = token.lineNumber() + 1; line <= commentLastLineNumber; line++) {
+ var lineStartPosition = this.snapshot.GetLineFromLineNumber(line).startPosition();
+ var lineIndent = this.GetLineIndentationForOffset(lineStartPosition);
+ var commentIndentationInfo = this.ApplyIndentationDelta2(lineIndent, commentFirstLineIndentationDelta);
+ if(commentIndentationInfo != null) {
+ var tokenStartPosition = lineStartPosition + lineIndent.length;
+ var commentIndentationEdit = this.GetIndentEdit(commentIndentationInfo, tokenStartPosition, false);
+ if(commentIndentationEdit != null) {
+ result.add(commentIndentationEdit);
+ }
+ }
+ }
+ }
+ return result;
+ };
+ Indenter.GetIndentSizeFromIndentText = function GetIndentSizeFromIndentText(indentText, editorOptions) {
+ return Indenter.GetIndentSizeFromText(indentText, editorOptions, false);
+ };
+ Indenter.GetIndentSizeFromText = function GetIndentSizeFromText(text, editorOptions, includeNonIndentChars) {
+ var indentSize = 0;
+ for(var i = 0; i < text.length; i++) {
+ var c = text.charAt(i);
+ if(c == '\t') {
+ indentSize = (indentSize + editorOptions.TabSize) - (indentSize % editorOptions.TabSize);
+ } else if(c == ' ') {
+ indentSize += 1;
+ } else {
+ if(includeNonIndentChars) {
+ indentSize += 1;
+ } else {
+ break;
+ }
+ }
+ }
+ return indentSize;
+ };
+ Indenter.prototype.GetSpecialCaseIndentation = function (token, node) {
+ var indentationInfo = null;
+ switch(token.Token) {
+ case Formatting.AuthorTokenKind.atkLCurly:
+ indentationInfo = this.GetSpecialCaseIndentationForLCurly(node);
+ return indentationInfo;
+ case Formatting.AuthorTokenKind.atkElse:
+ case Formatting.AuthorTokenKind.atkRBrack:
+ indentationInfo = node.GetNodeStartLineIndentation(this);
+ return indentationInfo;
+ case Formatting.AuthorTokenKind.atkRCurly:
+ if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock && node.AuthorNode.EdgeLabel == Formatting.AuthorParseNodeEdge.apneBody) {
+ node = node.Parent;
+ }
+ indentationInfo = node.GetNodeStartLineIndentation(this);
+ return indentationInfo;
+ case Formatting.AuthorTokenKind.atkWhile:
+ if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkDoWhile) {
+ indentationInfo = node.GetNodeStartLineIndentation(this);
+ return indentationInfo;
+ }
+ return null;
+ case Formatting.AuthorTokenKind.atkSColon:
+ return this.GetSpecialCaseIndentationForSemicolon(token, node);
+ case Formatting.AuthorTokenKind.atkComment:
+ return this.GetSpecialCaseIndentationForComment(token, node);
+ default:
+ return indentationInfo;
+ }
+ };
+ Indenter.prototype.GetSpecialCaseIndentationForLCurly = function (node) {
+ var indentationInfo = null;
+ if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl || node.AuthorNode.EdgeLabel == Formatting.AuthorParseNodeEdge.apneThen || node.AuthorNode.EdgeLabel == Formatting.AuthorParseNodeEdge.apneElse) {
+ indentationInfo = node.GetNodeStartLineIndentation(this);
+ return indentationInfo;
+ } else if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkObject && !node.CanIndent()) {
+ return null;
+ }
+ indentationInfo = node.GetEffectiveIndentation(this);
+ return indentationInfo;
+ };
+ Indenter.prototype.GetSpecialCaseIndentationForSemicolon = function (token, node) {
+ var indentationInfo = null;
+ if(this.smartIndent) {
+ indentationInfo = node.GetEffectiveChildrenIndentation(this);
+ return indentationInfo;
+ } else {
+ if(node.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkFor) {
+ var semiColonStartSpan = new Formatting.Span(token.Span.startPosition(), 0);
+ node = Formatting.ParseTree.FindCommonParentNode(semiColonStartSpan, semiColonStartSpan, node);
+ indentationInfo = node.GetEffectiveChildrenIndentation(this);
+ return indentationInfo;
+ }
+ }
+ return null;
+ };
+ Indenter.prototype.GetSpecialCaseIndentationForComment = function (token, node) {
+ var indentationInfo = null;
+ var twoCharSpan = token.Span.Intersection(new Formatting.Span(token.Span.startPosition(), 2));
+ if(twoCharSpan != null && (twoCharSpan.GetText() == "//" || twoCharSpan.GetText() == "/*")) {
+ while(node.ChildrenIndentationDelta == null && node.Parent != null) {
+ node = node.Parent;
+ }
+ if(this.CanIndentComment(token, node)) {
+ indentationInfo = node.GetEffectiveChildrenIndentationForComment(this);
+ } else {
+ indentationInfo = this.ApplyIndentationDeltaFromParent(token, node);
+ }
+ }
+ return indentationInfo;
+ };
+ Indenter.prototype.CanIndentComment = function (token, node) {
+ switch(node.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkProg:
+ case Formatting.AuthorParseNodeKind.apnkBlock:
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ case Formatting.AuthorParseNodeKind.apnkCase:
+ case Formatting.AuthorParseNodeKind.apnkDefaultCase:
+ case Formatting.AuthorParseNodeKind.apnkIf:
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkWhile:
+ case Formatting.AuthorParseNodeKind.apnkWith:
+ case Formatting.AuthorParseNodeKind.apnkDoWhile:
+ case Formatting.AuthorParseNodeKind.apnkObject:
+ return true;
+ case Formatting.AuthorParseNodeKind.apnkFncDecl:
+ var result = true;
+ var children = Formatting.ParseNodeExtensions.FindChildrenWithEdge(node, Formatting.AuthorParseNodeEdge.apneArgument);
+ children.foreach(function (argumentNode) {
+ if(token.Span.startPosition() < argumentNode.AuthorNode.Details.StartOffset) {
+ result = false;
+ }
+ });
+ return result;
+ }
+ return false;
+ };
+ Indenter.prototype.ApplyScriptBlockIndentation = function (languageHostIndentation, tree) {
+ if(languageHostIndentation == null || tree.StartNodeSelf == null) {
+ return;
+ }
+ var scriptBlockIndentation = this.ApplyIndentationLevel(languageHostIndentation, 1);
+ tree.Root.SetIndentationOverride(scriptBlockIndentation);
+ };
+ Indenter.prototype.GetIndentEdit = function (indentInfo, tokenStartPosition, sameLineIndent) {
+ var indentText = this.ApplyIndentationLevel(indentInfo.Prefix, indentInfo.Level);
+ if(sameLineIndent) {
+ return new Formatting.TextEditInfo(tokenStartPosition, 0, indentText);
+ } else {
+ var snapshotLine = this.snapshot.GetLineFromPosition(tokenStartPosition);
+ var currentIndentSpan = new Formatting.Span(snapshotLine.startPosition(), tokenStartPosition - snapshotLine.startPosition());
+ var currentIndentText = this.snapshot.GetText(currentIndentSpan);
+ if(currentIndentText !== indentText) {
+ if(this.logger.debug()) {
+ for(var i = 0, len = currentIndentText.length; i < len; i++) {
+ var c = currentIndentText.charCodeAt(i);
+ if(!Formatting.StringUtils.IsWhiteSpace(c)) {
+ Formatting.Debug.Fail("Formatting error: Will remove user code when indenting the line: " + snapshotLine.getText());
+ break;
+ }
+ }
+ }
+ return new Formatting.TextEditInfo(currentIndentSpan.start(), currentIndentSpan.length(), indentText);
+ }
+ }
+ return null;
+ };
+ Indenter.prototype.ApplyIndentationLevel = function (existingIndentation, level) {
+ var indentSize = this.editorOptions.IndentSize;
+ var tabSize = this.editorOptions.TabSize;
+ var convertTabsToSpaces = this.editorOptions.ConvertTabsToSpaces;
+ if(level < 0) {
+ if(Formatting.StringUtils.IsNullOrEmpty(existingIndentation)) {
+ return "";
+ }
+ var totalIndent = 0;
+ Formatting.StringUtils.foreach(existingIndentation, function (c) {
+ if(c == '\t') {
+ totalIndent += tabSize;
+ } else {
+ totalIndent++;
+ }
+ });
+ totalIndent += level * indentSize;
+ if(totalIndent < 0) {
+ return "";
+ } else {
+ return this.GetIndentString(null, totalIndent, tabSize, convertTabsToSpaces);
+ }
+ }
+ var totalIndentSize = level * indentSize;
+ return this.GetIndentString(existingIndentation, totalIndentSize, tabSize, convertTabsToSpaces);
+ };
+ Indenter.prototype.GetIndentString = function (prefix, totalIndentSize, tabSize, convertTabsToSpaces) {
+ var tabString = convertTabsToSpaces ? Formatting.StringUtils.create(' ', tabSize) : "\t";
+ var text = "";
+ if(!Formatting.StringUtils.IsNullOrEmpty(prefix)) {
+ text += prefix;
+ }
+ var pos = 0;
+ while(pos <= totalIndentSize - tabSize) {
+ text += tabString;
+ pos += tabSize;
+ }
+ while(pos < totalIndentSize) {
+ text += ' ';
+ pos++;
+ }
+ return text;
+ };
+ Indenter.prototype.ApplyIndentationDeltaFromParent = function (token, node) {
+ var indentationInfo = null;
+ var indentableParent = node;
+ while(indentableParent != null && !indentableParent.CanIndent()) {
+ indentableParent = indentableParent.Parent;
+ }
+ if(indentableParent != null && indentableParent.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkProg) {
+ var parentIndentationDeltaSize = this.GetIndentationDelta(indentableParent.AuthorNode.Details.StartOffset, token.Span.startPosition());
+ if(parentIndentationDeltaSize !== undefined) {
+ indentationInfo = this.ApplyIndentationDelta1(token.Span.startPosition(), parentIndentationDeltaSize);
+ }
+ }
+ return indentationInfo;
+ };
+ Indenter.prototype.ApplyIndentationDelta1 = function (tokenStartPosition, delta) {
+ var snapshotLine = this.snapshot.GetLineFromPosition(tokenStartPosition);
+ var currentIndentSpan = new Formatting.Span(snapshotLine.startPosition(), tokenStartPosition - snapshotLine.startPosition());
+ var currentIndent = this.snapshot.GetText(currentIndentSpan);
+ return this.ApplyIndentationDelta2(currentIndent, delta);
+ };
+ Indenter.prototype.ApplyIndentationDelta2 = function (currentIndent, delta) {
+ if(delta == 0) {
+ return null;
+ }
+ var currentIndentSize = Indenter.GetIndentSizeFromIndentText(currentIndent, this.editorOptions);
+ var newIndentSize = currentIndentSize + delta;
+ if(newIndentSize < 0) {
+ newIndentSize = 0;
+ }
+ var newIndent = this.GetIndentString(null, newIndentSize, this.editorOptions.TabSize, this.editorOptions.ConvertTabsToSpaces);
+ if(newIndent != null) {
+ return new Formatting.IndentationInfo(newIndent, 0);
+ }
+ return null;
+ };
+ Indenter.prototype.GetIndentationDelta = function (tokenStartPosition, childTokenStartPosition) {
+ Formatting.Debug.Assert(childTokenStartPosition !== undefined, "Error: caller must pass 'null' for undefined position");
+ var indentationDeltaSize = this.offsetIndentationDeltas.GetValue(tokenStartPosition);
+ if(indentationDeltaSize === null) {
+ var indentEditInfo = this.indentationBag.FindIndent(tokenStartPosition);
+ if(indentEditInfo == null) {
+ return null;
+ }
+ var origIndentText = this.snapshot.GetText(new Formatting.Span(indentEditInfo.OrigIndentPosition, indentEditInfo.OrigIndentLength()));
+ var newIndentText = indentEditInfo.Indentation();
+ var origIndentSize = Indenter.GetIndentSizeFromText(origIndentText, this.editorOptions, true);
+ var newIndentSize = Indenter.GetIndentSizeFromIndentText(newIndentText, this.editorOptions);
+ if(childTokenStartPosition !== null) {
+ var childTokenLineStartPosition = this.snapshot.GetLineFromPosition(childTokenStartPosition).startPosition();
+ var childIndentText = this.snapshot.GetText(new Formatting.Span(childTokenLineStartPosition, childTokenStartPosition - childTokenLineStartPosition));
+ var childIndentSize = Indenter.GetIndentSizeFromIndentText(childIndentText, this.editorOptions);
+ if(childIndentSize < origIndentSize) {
+ origIndentSize = Indenter.GetIndentSizeFromIndentText(origIndentText, this.editorOptions);
+ }
+ }
+ indentationDeltaSize = newIndentSize - origIndentSize;
+ this.offsetIndentationDeltas.Add(tokenStartPosition, indentationDeltaSize);
+ }
+ return indentationDeltaSize;
+ };
+ Indenter.prototype.FillInheritedIndentation = function (tree) {
+ var offset = -1;
+ var indentNode = null;
+ if(tree.StartNodeSelf != null) {
+ if(!this.smartIndent && tree.StartNodePreviousSibling !== null && tree.StartNodeSelf.AuthorNode.Label == 0 && tree.StartNodePreviousSibling.Label == 0) {
+ indentNode = tree.StartNodeSelf;
+ offset = tree.StartNodePreviousSibling.Details.StartOffset;
+ var lineNum = this.snapshot.GetLineNumberFromPosition(offset);
+ var node = indentNode;
+ while(node.Parent != null && this.snapshot.GetLineNumberFromPosition(node.Parent.AuthorNode.Details.StartOffset) == lineNum) {
+ node = node.Parent;
+ if(node.CanIndent()) {
+ indentNode = node;
+ indentNode.IndentationDelta = 0;
+ }
+ }
+ } else {
+ var parent;
+ if(this.smartIndent) {
+ parent = tree.StartNodeSelf;
+ while(parent != null && parent.AuthorNode.Details.StartOffset == this.firstToken.Span.startPosition()) {
+ parent = parent.Parent;
+ }
+ } else {
+ var startNodeLineNumber = this.snapshot.GetLineNumberFromPosition(tree.StartNodeSelf.AuthorNode.Details.StartOffset);
+ parent = tree.StartNodeSelf.Parent;
+ while(parent != null && startNodeLineNumber == this.snapshot.GetLineNumberFromPosition(parent.AuthorNode.Details.StartOffset)) {
+ parent = parent.Parent;
+ }
+ }
+ while(parent != null && !parent.CanIndent()) {
+ parent = parent.Parent;
+ }
+ if(parent != null && parent.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkProg) {
+ offset = parent.AuthorNode.Details.StartOffset;
+ indentNode = parent;
+ }
+ }
+ }
+ if(indentNode != null) {
+ var indentOverride = this.GetLineIndentationForOffset(offset);
+ if(!this.smartIndent && tree.StartNodePreviousSibling !== null && indentNode.Parent != null) {
+ Formatting.ParseNodeExtensions.GetChildren(indentNode.Parent).foreach(function (sibling) {
+ if(sibling !== indentNode) {
+ if(sibling.CanIndent()) {
+ sibling.SetIndentationOverride(indentOverride);
+ }
+ }
+ });
+ }
+ var lastDelta = 0;
+ var lastLine = this.snapshot.GetLineNumberFromPosition(indentNode.AuthorNode.Details.StartOffset);
+ do {
+ var currentLine = this.snapshot.GetLineNumberFromPosition(indentNode.AuthorNode.Details.StartOffset);
+ if(lastLine != currentLine) {
+ lastLine = currentLine;
+ indentOverride = this.ApplyIndentationLevel(indentOverride, -lastDelta);
+ lastDelta = 0;
+ }
+ if(indentNode.CanIndent()) {
+ indentNode.SetIndentationOverride(indentOverride);
+ lastDelta = indentNode.IndentationDelta;
+ }
+ indentNode = indentNode.Parent;
+ }while(indentNode != null);
+ }
+ };
+ Indenter.prototype.GetLineIndentationForOffset = function (offset) {
+ var indentationEdit;
+ indentationEdit = this.indentationBag.FindIndent(offset);
+ if(indentationEdit != null) {
+ return indentationEdit.Indentation();
+ } else {
+ var line = this.snapshot.GetLineFromPosition(offset);
+ var lineText = line.getText();
+ var index = 0;
+ while(index < lineText.length && (lineText.charAt(index) == ' ' || lineText.charAt(index) == '\t')) {
+ ++index;
+ }
+ return lineText.substr(0, index);
+ }
+ };
+ Indenter.prototype.RegisterIndentation = function (indent, sameLineIndent) {
+ var indentationInfo = null;
+ if(sameLineIndent) {
+ var lineStartPosition = this.snapshot.GetLineFromPosition(indent.Position).startPosition();
+ var lineIndentLength = indent.Position - lineStartPosition;
+ indentationInfo = Formatting.IndentationEditInfo.create2(indent.Position, indent.ReplaceWith, lineStartPosition, lineIndentLength);
+ } else {
+ indentationInfo = new Formatting.IndentationEditInfo(indent);
+ }
+ this.indentationBag.AddIndent(indentationInfo);
+ };
+ Indenter.prototype.RegisterIndentation2 = function (position, indent) {
+ this.RegisterIndentation(new Formatting.TextEditInfo(position, 0, indent), false);
+ };
+ Indenter.prototype.AdjustStartOffsetIfNeeded = function (token, node) {
+ if(token == null) {
+ return;
+ }
+ var updateStartOffset = false;
+ switch(token.Token) {
+ case Formatting.AuthorTokenKind.atkFunction:
+ updateStartOffset = node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl;
+ break;
+ case Formatting.AuthorTokenKind.atkLCurly:
+ updateStartOffset = node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkObject;
+ break;
+ case Formatting.AuthorTokenKind.atkLBrack:
+ updateStartOffset = node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkArray;
+ break;
+ }
+ if(updateStartOffset) {
+ Formatting.ParseNodeExtensions.SetNodeSpan(node, token.Span.startPosition(), node.AuthorNode.Details.EndOffset);
+ }
+ };
+ Indenter.prototype.IsMultiLineString = function (token) {
+ return token.tokenID === TypeScript.TokenID.StringLiteral && this.snapshot.GetLineNumberFromPosition(token.Span.endPosition()) > this.snapshot.GetLineNumberFromPosition(token.Span.startPosition());
+ };
+ return Indenter;
+ })();
+ Formatting.Indenter = Indenter;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var MatchingBlockFinderTask = (function () {
+ function MatchingBlockFinderTask(bracePoint, FileAuthoringProxy) {
+ this.bracePoint = bracePoint;
+ this.FileAuthoringProxy = FileAuthoringProxy;
+ }
+ MatchingBlockFinderTask.prototype.Run = function () {
+ var parseCursor = this.FileAuthoringProxy.GetASTCursor();
+ parseCursor.SeekToOffset(this.bracePoint.position, true);
+ return this.FindMatchingBlockSpan(parseCursor);
+ };
+ MatchingBlockFinderTask.prototype.FindMatchingBlockSpan = function (parser) {
+ var currentNode = parser.Current();
+ while(currentNode.Kind != Formatting.AuthorParseNodeKind.apnkEmptyNode) {
+ if(currentNode.ast != null) {
+ switch(currentNode.ast.nodeType) {
+ case TypeScript.NodeType.InterfaceDeclaration:
+ case TypeScript.NodeType.ClassDeclaration:
+ case TypeScript.NodeType.ModuleDeclaration:
+ return Formatting.Span.FromBounds(currentNode.ast.minChar, currentNode.ast.limChar);
+ case TypeScript.NodeType.ImportDeclaration:
+ return new Formatting.Span(currentNode.StartOffset, currentNode.EndOffset - currentNode.StartOffset);
+ }
+ }
+ switch(currentNode.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkProg:
+ return null;
+ case Formatting.AuthorParseNodeKind.apnkVarDecl:
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ case Formatting.AuthorParseNodeKind.apnkCase:
+ case Formatting.AuthorParseNodeKind.apnkDefaultCase:
+ case Formatting.AuthorParseNodeKind.apnkTry:
+ case Formatting.AuthorParseNodeKind.apnkCatch:
+ case Formatting.AuthorParseNodeKind.apnkFinally:
+ case Formatting.AuthorParseNodeKind.apnkIf:
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkWhile:
+ case Formatting.AuthorParseNodeKind.apnkDoWhile:
+ case Formatting.AuthorParseNodeKind.apnkWith:
+ case Formatting.AuthorParseNodeKind.apnkCall:
+ case Formatting.AuthorParseNodeKind.apnkReturn:
+ case Formatting.AuthorParseNodeKind.apnkAsg:
+ case Formatting.AuthorParseNodeKind.apnkAsgAdd:
+ case Formatting.AuthorParseNodeKind.apnkAsgSub:
+ case Formatting.AuthorParseNodeKind.apnkAsgMul:
+ case Formatting.AuthorParseNodeKind.apnkAsgDiv:
+ case Formatting.AuthorParseNodeKind.apnkAsgMod:
+ case Formatting.AuthorParseNodeKind.apnkAsgAnd:
+ case Formatting.AuthorParseNodeKind.apnkAsgXor:
+ case Formatting.AuthorParseNodeKind.apnkAsgOr:
+ case Formatting.AuthorParseNodeKind.apnkAsgLsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRs2:
+ return new Formatting.Span(currentNode.StartOffset, currentNode.EndOffset - currentNode.StartOffset);
+ case Formatting.AuthorParseNodeKind.apnkBlock:
+ if((currentNode.Flags & Formatting.AuthorParseNodeFlags.apnfSyntheticNode) != Formatting.AuthorParseNodeFlags.apnfSyntheticNode) {
+ var parent = parser.Parent();
+ switch(parent.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkBlock:
+ case Formatting.AuthorParseNodeKind.apnkList:
+ return new Formatting.Span(currentNode.StartOffset, currentNode.EndOffset - currentNode.StartOffset);
+ }
+ }
+ currentNode = parser.MoveUp();
+ continue;
+ case Formatting.AuthorParseNodeKind.apnkFncDecl: {
+ var start = parser.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpFunctionKeywordMin);
+ start = (start == 0) ? currentNode.StartOffset : start;
+ var end = parser.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpRCurlyMin);
+ end = (end == 0) ? currentNode.EndOffset : end + 1;
+ return new Formatting.Span(start, end - start);
+ }
+ case Formatting.AuthorParseNodeKind.apnkObject: {
+ var start = parser.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpLCurlyMin);
+ start = (start == 0) ? currentNode.StartOffset : start;
+ var end = parser.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpRCurlyMin);
+ end = (end == 0) ? currentNode.EndOffset : end + 1;
+ return new Formatting.Span(start, end - start);
+ }
+ default:
+ currentNode = parser.MoveUp();
+ continue;
+ }
+ }
+ return null;
+ };
+ return MatchingBlockFinderTask;
+ })();
+ Formatting.MatchingBlockFinderTask = MatchingBlockFinderTask;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var ParseNode = (function () {
+ function ParseNode() {
+ this._children = null;
+ this.blockSpan = null;
+ this.indentationOverride = null;
+ this.Parent = null;
+ this.AuthorNode = null;
+ this.IsIndentationOverrideEdge = false;
+ this.IndentationDelta = null;
+ this.ChildrenIndentationDelta = null;
+ this.TokenTagIndex = null;
+ }
+ ParseNode.prototype.children = function () {
+ return this._children;
+ };
+ ParseNode.prototype.addChildNode = function (node) {
+ if(this._children === null) {
+ this._children = new Formatting.List_ParseNode();
+ }
+ var count = this._children.count();
+ if(count === 0) {
+ this._children.add(node);
+ } else {
+ var startOffset = node.AuthorNode.Details.StartOffset;
+ var maxOffset = this._children.get(count - 1).AuthorNode.Details.StartOffset;
+ if(startOffset >= maxOffset) {
+ this._children.add(node);
+ } else {
+ var pivot = Formatting.ParseNodeExtensions.findNodeInsertionPivot(this._children, node.AuthorNode.Details.StartOffset);
+ if(pivot < 0) {
+ this._children.insert(~pivot, node);
+ } else {
+ this._children.insert(pivot + 1, node);
+ }
+ }
+ }
+ };
+ ParseNode.prototype.CanIndent = function () {
+ {
+ return this.IndentationDelta != null;
+ }
+ };
+ ParseNode.prototype.CoverSpan = function (span) {
+ var details = this.AuthorNode.Details;
+ return span.start() >= details.StartOffset && span.end() <= details.EndOffset;
+ };
+ ParseNode.prototype.SetIndentationOverride = function (newIndentationOverride) {
+ this.indentationOverride = newIndentationOverride;
+ };
+ ParseNode.prototype.GetNodeStartLineIndentation = function (indentResolver) {
+ var node = this;
+ var prefix = null;
+ while(node != null && !node.CanIndent() && !node.IsIndentationOverrideEdge) {
+ node = node.Parent;
+ }
+ if(node != null) {
+ if(node.indentationOverride == null) {
+ node.indentationOverride = indentResolver.GetLineIndentationForOffset(node.AuthorNode.Details.StartOffset);
+ }
+ prefix = node.indentationOverride;
+ }
+ return new Formatting.IndentationInfo(prefix, 0);
+ };
+ ParseNode.prototype.GetEffectiveIndentation = function (indentResolver) {
+ var node = this;
+ var prefix = null;
+ var level = 0;
+ while(node != null && !node.CanIndent() && !node.IsIndentationOverrideEdge) {
+ node = node.Parent;
+ }
+ if(node != null) {
+ if(node.indentationOverride != null) {
+ prefix = node.indentationOverride;
+ } else {
+ if(node.CanIndent()) {
+ level = node.IndentationDelta;
+ if(!!node.AuthorNode.Label) {
+ level++;
+ }
+ node = node.Parent;
+ while(node != null) {
+ if(node.indentationOverride != null) {
+ prefix = node.indentationOverride;
+ break;
+ }
+ if(node.CanIndent() || node.IsIndentationOverrideEdge) {
+ node.indentationOverride = indentResolver.GetLineIndentationForOffset(node.AuthorNode.Details.StartOffset);
+ prefix = node.indentationOverride;
+ break;
+ }
+ node = node.Parent;
+ }
+ } else if(node.IsIndentationOverrideEdge) {
+ node.indentationOverride = indentResolver.GetLineIndentationForOffset(node.AuthorNode.Details.StartOffset);
+ prefix = node.indentationOverride;
+ }
+ }
+ }
+ return new Formatting.IndentationInfo(prefix, level);
+ };
+ ParseNode.prototype.GetEffectiveChildrenIndentation = function (indentResolver) {
+ var node = this;
+ var indentation = null;
+ while(node.ChildrenIndentationDelta == null && node.Parent != null) {
+ node = node.Parent;
+ }
+ if(node.ChildrenIndentationDelta != null) {
+ indentation = node.GetEffectiveIndentation(indentResolver);
+ indentation.Level += node.ChildrenIndentationDelta;
+ }
+ return indentation;
+ };
+ ParseNode.prototype.GetEffectiveChildrenIndentationForComment = function (indentResolver) {
+ var node = this;
+ var indentation = null;
+ while(node.Parent != null && (node.ChildrenIndentationDelta == null || node.IndentationDelta == null) && !ParseNode.IsNonIndentableException(node)) {
+ node = node.Parent;
+ }
+ if(node.ChildrenIndentationDelta != null) {
+ indentation = new Formatting.IndentationInfo();
+ indentation.Level = node.ChildrenIndentationDelta;
+ if(this.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkProg) {
+ indentation.Prefix = indentResolver.GetLineIndentationForOffset(node.AuthorNode.Details.StartOffset);
+ }
+ }
+ return indentation;
+ };
+ ParseNode.IsNonIndentableException = function IsNonIndentableException(node) {
+ return node.IndentationDelta == null && (node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkObject || node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl);
+ };
+ ParseNode.prototype.GetBlockSpan = function (fileAuthoringProxy, tokens) {
+ if(this.blockSpan != null) {
+ return this.blockSpan;
+ }
+ var start = this.AuthorNode.Details.StartOffset;
+ var end = this.AuthorNode.Details.EndOffset;
+ var implicitBlockNode = null;
+ if(this.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl || this.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkSwitch) {
+ implicitBlockNode = this;
+ } else if(this.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkList && this.Parent != null && this.Parent.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl) {
+ implicitBlockNode = this.Parent;
+ }
+ if(implicitBlockNode != null) {
+ if(implicitBlockNode.TokenTagIndex != null) {
+ var functionTokenIndex = implicitBlockNode.TokenTagIndex;
+ for(var i = functionTokenIndex + 1; i < tokens.count(); i++) {
+ if(tokens.get(i).Token == Formatting.AuthorTokenKind.atkLCurly && tokens.get(i).Span.startPosition() <= end) {
+ start = tokens.get(i).Span.startPosition();
+ break;
+ }
+ }
+ } else {
+ var astCursor = fileAuthoringProxy.GetASTCursor();
+ {
+ astCursor.MoveToEnclosingNode(implicitBlockNode.AuthorNode.Details.StartOffset, implicitBlockNode.AuthorNode.Details.EndOffset);
+ var leftCurlyPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpLCurlyMin);
+ if(leftCurlyPos != 0 && leftCurlyPos <= end) {
+ start = leftCurlyPos;
+ }
+ }
+ }
+ } else if(this.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkBlock) {
+ var found = false;
+ Formatting.ParseNodeExtensions.GetChildren(this).foreach(function (child) {
+ if(child.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock) {
+ if(!found) {
+ found = true;
+ start = child.AuthorNode.Details.StartOffset;
+ end = child.AuthorNode.Details.EndOffset;
+ }
+ }
+ });
+ }
+ Formatting.Debug.Assert(start <= end, "Expecting start to be before end.");
+ this.blockSpan = new Formatting.Span(start, end - start);
+ return this.blockSpan;
+ };
+ ParseNode.prototype.toString = function () {
+ var text = this.AuthorNode.Level + ": " + (Formatting.AuthorParseNodeKind)._map[this.AuthorNode.Details.Kind] + " - " + (TypeScript.NodeType)._map[this.AuthorNode.Details.nodeType] + " (" + (Formatting.AuthorParseNodeEdge)._map[this.AuthorNode.EdgeLabel] + ") -- I:" + this.IndentationDelta + ",IC:" + this.ChildrenIndentationDelta + " -- (" + this.AuthorNode.Details.StartOffset + "," + this.AuthorNode.Details.EndOffset + ") -- F:(" + this.AuthorNode.Details.Flags + ")";
+ return text;
+ };
+ return ParseNode;
+ })();
+ Formatting.ParseNode = ParseNode;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var ParseNodeExtensions = (function () {
+ function ParseNodeExtensions() { }
+ ParseNodeExtensions.GetChildren = function GetChildren(node) {
+ if(node == null || node.children() == null) {
+ return new Formatting.List_ParseNode();
+ }
+ return node.children();
+ };
+ ParseNodeExtensions.FindChildrenWithEdge = function FindChildrenWithEdge(node, edge) {
+ var result = new Formatting.List_ParseNode();
+ ParseNodeExtensions.GetChildren(node).foreach(function (item) {
+ if(item.AuthorNode.EdgeLabel == edge) {
+ result.add(item);
+ }
+ });
+ return result;
+ };
+ ParseNodeExtensions.FindChildWithEdge = function FindChildWithEdge(node, edge) {
+ return Formatting.FirstOrDefault(ParseNodeExtensions.GetChildren(node).Where(function (c) {
+ return c.AuthorNode.EdgeLabel == edge;
+ }), function () {
+ return true;
+ });
+ };
+ ParseNodeExtensions.ForAllChildren = function ForAllChildren(node, action) {
+ ParseNodeExtensions.GetChildren(node).foreach(action);
+ };
+ ParseNodeExtensions.comparer = function comparer(position, item) {
+ return position - item.AuthorNode.Details.StartOffset;
+ };
+ ParseNodeExtensions.findNodeInsertionPivot = function findNodeInsertionPivot(nodes, startOffset) {
+ if(nodes.count() == 0) {
+ return 0;
+ }
+ return Formatting.BinarySearch(nodes, startOffset, ParseNodeExtensions.comparer);
+ };
+ ParseNodeExtensions.TryFindNodeIndexForStartOffset = function TryFindNodeIndexForStartOffset(nodes, startOffset) {
+ var targetNodeIndex = -1;
+ if(nodes.count() > 0) {
+ var pivot = Formatting.BinarySearch(nodes, startOffset, ParseNodeExtensions.comparer);
+ if(pivot < 0) {
+ pivot = ~pivot - 1;
+ targetNodeIndex = pivot;
+ } else {
+ targetNodeIndex = pivot;
+ }
+ }
+ return targetNodeIndex;
+ };
+ ParseNodeExtensions.TryFindNodeForSpan = function TryFindNodeForSpan(nodes, span) {
+ var nodeIndex = ParseNodeExtensions.TryFindNodeIndexForStartOffset(nodes, span.start());
+ if(nodeIndex >= 0 && nodeIndex < nodes.count()) {
+ var node = nodes.get(nodeIndex);
+ if(node.CoverSpan(span)) {
+ return node;
+ }
+ }
+ return null;
+ };
+ ParseNodeExtensions.SetNodeSpan = function SetNodeSpan(node, newStartOffset, newEndOffset) {
+ var authorParseNode = node.AuthorNode;
+ if(newStartOffset != authorParseNode.Details.StartOffset || newEndOffset != authorParseNode.Details.EndOffset) {
+ var newAuthorNode = new Formatting.AuthorParseNode();
+ newAuthorNode.Details = new Formatting.AuthorParseNodeDetails();
+ newAuthorNode.Details.StartOffset = newStartOffset;
+ newAuthorNode.Details.EndOffset = newEndOffset;
+ newAuthorNode.Details.Flags = authorParseNode.Details.Flags;
+ newAuthorNode.Details.Kind = authorParseNode.Details.Kind;
+ newAuthorNode.Details.nodeType = authorParseNode.Details.nodeType;
+ newAuthorNode.Details.ast = authorParseNode.Details.ast;
+ newAuthorNode.EdgeLabel = authorParseNode.EdgeLabel;
+ newAuthorNode.Label = authorParseNode.Label;
+ newAuthorNode.Level = authorParseNode.Level;
+ newAuthorNode.Name = authorParseNode.Name;
+ node.AuthorNode = newAuthorNode;
+ }
+ };
+ return ParseNodeExtensions;
+ })();
+ Formatting.ParseNodeExtensions = ParseNodeExtensions;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var ParseTree = (function () {
+ function ParseTree(fileAuthoringProxy, span, tokens, onlySelfAndAncestors) {
+ this.StartNodeSelf = null;
+ this.StartNodePreviousSibling = null;
+ if(tokens != null) {
+ var firstToken = Formatting.FirstOrDefault(tokens, function (t) {
+ return t.Span.startPosition() >= span.start() && t.Token != Formatting.AuthorTokenKind.atkComment && t.Token != Formatting.AuthorTokenKind.atkSColon && t.Token != Formatting.AuthorTokenKind.atkComma;
+ });
+ if(firstToken != null) {
+ var firstTokenStart = firstToken.Span.Start;
+ var lastToken = Formatting.LastOrDefault(tokens, function (t) {
+ return t.Span.endPosition() <= span.end() && t.Token != Formatting.AuthorTokenKind.atkComment && t.Token != Formatting.AuthorTokenKind.atkSColon && t.Token != Formatting.AuthorTokenKind.atkComma;
+ });
+ if(lastToken != null) {
+ var lastTokenEnd = lastToken.Span.End;
+ if(firstTokenStart < lastTokenEnd) {
+ span = new Formatting.Span(firstTokenStart, lastTokenEnd - firstTokenStart);
+ }
+ }
+ }
+ }
+ this.Initialize(fileAuthoringProxy, span, onlySelfAndAncestors);
+ }
+ ParseTree.FindCommonParentNode = function FindCommonParentNode(leftSpan, rightSpan, context) {
+ if(context.CoverSpan(leftSpan) && context.CoverSpan(rightSpan)) {
+ Formatting.Debug.Assert(leftSpan.start() <= rightSpan.start(), "left token should be before the right token");
+ if(context.children() != null) {
+ var child = Formatting.ParseNodeExtensions.TryFindNodeForSpan(context.children(), leftSpan);
+ if(child != null && child.CoverSpan(rightSpan)) {
+ return ParseTree.FindCommonParentNode(leftSpan, rightSpan, child);
+ }
+ }
+ return context;
+ } else {
+ if(context.Parent == null) {
+ return context;
+ } else {
+ return ParseTree.FindCommonParentNode(leftSpan, rightSpan, context.Parent);
+ }
+ }
+ };
+ ParseTree.prototype.Initialize = function (fileAuthoringProxy, span, onlySelfAndAncestors) {
+ var astCursor = fileAuthoringProxy.GetASTCursor();
+ {
+ if(span.length() == 0) {
+ astCursor.SeekToOffset(span.start(), false);
+ } else {
+ astCursor.MoveToEnclosingNode(span.start(), span.end());
+ }
+ var selfAndDescendantsNodes = new Formatting.List_ParseNode();
+ var parseNodeSet = astCursor.GetSubTree(onlySelfAndAncestors ? 0 : -1);
+ {
+ if(parseNodeSet.Count() > 0) {
+ var authorNodes = parseNodeSet.GetItems(0, parseNodeSet.Count());
+ if(authorNodes[0].Details.Kind != Formatting.AuthorParseNodeKind.apnkEndCode) {
+ var nodeEdge = astCursor.GetEdgeLabel();
+ if(nodeEdge != Formatting.AuthorParseNodeEdge.apneNone) {
+ var newAuthorNode = new Formatting.AuthorParseNode();
+ newAuthorNode.Level = 0;
+ newAuthorNode.Label = authorNodes[0].Label;
+ newAuthorNode.Name = authorNodes[0].Name;
+ newAuthorNode.Details = authorNodes[0].Details;
+ newAuthorNode.EdgeLabel = nodeEdge;
+ authorNodes[0] = newAuthorNode;
+ }
+ }
+ authorNodes.forEach(function (authorParseNode) {
+ if(authorParseNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkEndCode) {
+ var node = new Formatting.ParseNode();
+ node.AuthorNode = authorParseNode;
+ selfAndDescendantsNodes.add(node);
+ }
+ });
+ ParseTree.AdjustNodeSpanIfNeeded(astCursor, selfAndDescendantsNodes.get(0));
+ }
+ }
+ this.StartNodeSelf = ParseTree.FindStartSelfNode(selfAndDescendantsNodes, span);
+ var nodeLevel = 0;
+ var ancestorNodes = new Formatting.List_ParseNode();
+ var ancestorNodeDetails = astCursor.MoveUp();
+ if(!onlySelfAndAncestors && this.StartNodeSelf != null) {
+ if(this.StartNodeSelf.AuthorNode.Level > 0) {
+ for(var i = selfAndDescendantsNodes.count() - 1; i >= 0; --i) {
+ var sibling = selfAndDescendantsNodes.get(i).AuthorNode;
+ if(sibling.Level == this.StartNodeSelf.AuthorNode.Level && ParseTree.IsSiblingEdge(sibling.EdgeLabel) && sibling.Details.EndOffset < this.StartNodeSelf.AuthorNode.Details.StartOffset) {
+ this.StartNodePreviousSibling = sibling;
+ break;
+ }
+ }
+ } else if(this.StartNodeSelf.AuthorNode.Level == 0) {
+ parseNodeSet = astCursor.GetSubTree(2);
+ {
+ if(parseNodeSet.Count() > 0) {
+ var nodes = parseNodeSet.GetItems(0, parseNodeSet.Count());
+ var previousSibling = ParseTree.GetPreviousSibling(this.StartNodeSelf.AuthorNode, nodes);
+ if(previousSibling !== null) {
+ this.StartNodePreviousSibling = previousSibling;
+ }
+ }
+ }
+ }
+ }
+ while(ancestorNodeDetails.Kind != Formatting.AuthorParseNodeKind.apnkEmptyNode) {
+ var nodeEdge = astCursor.GetEdgeLabel();
+ var node = new Formatting.ParseNode();
+ node.AuthorNode = new Formatting.AuthorParseNode();
+ node.AuthorNode.Details = ancestorNodeDetails;
+ node.AuthorNode.Level = --nodeLevel;
+ node.AuthorNode.EdgeLabel = nodeEdge;
+ ParseTree.AdjustNodeSpanIfNeeded(astCursor, node);
+ ancestorNodes.add(node);
+ ancestorNodeDetails = astCursor.MoveUp();
+ }
+ for(var i = 0; i < ancestorNodes.count(); i++) {
+ selfAndDescendantsNodes.insert(0, ancestorNodes.get(i));
+ }
+ this.Root = ParseTree.BuildTree(selfAndDescendantsNodes);
+ }
+ };
+ ParseTree.GetPreviousSibling = function GetPreviousSibling(startNodeSelf, nodes) {
+ var previousSibling = null;
+ var siblingLevel = -1;
+ var i = nodes.length - 1;
+ for(; i > 0; i--) {
+ if(nodes[i].Details.Equals(startNodeSelf.Details)) {
+ siblingLevel = nodes[i].Level;
+ break;
+ }
+ }
+ for(; i > 0; i--) {
+ var node = nodes[i];
+ if(node.Level == siblingLevel && ParseTree.IsSiblingEdge(node.EdgeLabel) && node.Details.EndOffset < startNodeSelf.Details.StartOffset) {
+ previousSibling = node;
+ break;
+ }
+ }
+ return previousSibling;
+ };
+ ParseTree.FindStartSelfNode = function FindStartSelfNode(selfAndDescendantsNodes, span) {
+ var candidateNodes = selfAndDescendantsNodes.Where(function (node) {
+ return node.AuthorNode.Details.StartOffset >= span.start() && node.AuthorNode.Details.StartOffset < span.end();
+ });
+ if(candidateNodes.count() == 0) {
+ return Formatting.FirstOrDefault(selfAndDescendantsNodes, function () {
+ return true;
+ });
+ }
+ return candidateNodes.get(0);
+ };
+ ParseTree.IsSiblingEdge = function IsSiblingEdge(edge) {
+ return edge == Formatting.AuthorParseNodeEdge.apneArgument || edge == Formatting.AuthorParseNodeEdge.apneListItem || edge == Formatting.AuthorParseNodeEdge.apneMember;
+ };
+ ParseTree.BuildTree = function BuildTree(parseNodes) {
+ var nodesEnumerator = parseNodes.GetEnumerator();
+ if(!nodesEnumerator.MoveNext()) {
+ return null;
+ }
+ var root = nodesEnumerator.Current();
+ var lastNode = root;
+ lastNode.Parent = null;
+ var lastLevel = lastNode.AuthorNode.Level;
+ while(nodesEnumerator.MoveNext()) {
+ var currentNode = nodesEnumerator.Current();
+ if(currentNode.AuthorNode.Level == lastLevel) {
+ currentNode.Parent = lastNode.Parent;
+ lastNode.Parent.addChildNode(currentNode);
+ lastNode = currentNode;
+ } else if(currentNode.AuthorNode.Level > lastLevel) {
+ currentNode.Parent = lastNode;
+ lastNode.addChildNode(currentNode);
+ lastNode = currentNode;
+ lastLevel = currentNode.AuthorNode.Level;
+ } else {
+ while(lastLevel > currentNode.AuthorNode.Level) {
+ lastNode = lastNode.Parent;
+ lastLevel--;
+ }
+ currentNode.Parent = lastNode.Parent;
+ lastNode.Parent.addChildNode(currentNode);
+ lastNode = currentNode;
+ }
+ }
+ return root;
+ };
+ ParseTree.DumpTree = function DumpTree(logger, parseNode) {
+ if(logger.information()) {
+ var text = "";
+ for(var i = -2; i <= parseNode.AuthorNode.Level; i++) {
+ text += " ";
+ }
+ text += parseNode.toString();
+ logger.log(text);
+ Formatting.ParseNodeExtensions.GetChildren(parseNode).foreach(function (child) {
+ ParseTree.DumpTree(logger, child);
+ });
+ }
+ };
+ ParseTree.AdjustNodeSpanIfNeeded = function AdjustNodeSpanIfNeeded(astCursor, node) {
+ var propertyToGetStart = null;
+ var propertyToGetEnd = null;
+ var authorParseNode = node.AuthorNode;
+ if(authorParseNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkObject) {
+ propertyToGetStart = Formatting.AuthorParseNodeProperty.apnpLCurlyMin;
+ propertyToGetEnd = Formatting.AuthorParseNodeProperty.apnpRCurlyMin;
+ } else if(authorParseNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkArray) {
+ propertyToGetStart = Formatting.AuthorParseNodeProperty.apnpLBrackMin;
+ propertyToGetEnd = Formatting.AuthorParseNodeProperty.apnpRBrackMin;
+ } else if(authorParseNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl) {
+ propertyToGetStart = Formatting.AuthorParseNodeProperty.apnpFunctionKeywordMin;
+ propertyToGetEnd = Formatting.AuthorParseNodeProperty.apnpRCurlyMin;
+ }
+ if(propertyToGetStart != null && propertyToGetEnd != null) {
+ var newStartOffset = astCursor.GetNodeProperty(propertyToGetStart);
+ if(newStartOffset == 0) {
+ newStartOffset = node.AuthorNode.Details.StartOffset;
+ }
+ var newEndOffset = astCursor.GetNodeProperty(propertyToGetEnd);
+ if(newEndOffset == 0) {
+ newEndOffset = node.AuthorNode.Details.EndOffset;
+ } else {
+ newEndOffset += 1;
+ }
+ Formatting.ParseNodeExtensions.SetNodeSpan(node, newStartOffset, newEndOffset);
+ }
+ };
+ return ParseTree;
+ })();
+ Formatting.ParseTree = ParseTree;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var Rule = (function () {
+ function Rule(Descriptor, Operation, Flag) {
+ if (typeof Flag === "undefined") { Flag = Formatting.RuleFlags.None; }
+ this.Descriptor = Descriptor;
+ this.Operation = Operation;
+ this.Flag = Flag;
+ }
+ Rule.prototype.toString = function () {
+ return "[desc=" + this.Descriptor + "," + "operation=" + this.Operation + "," + "flag=" + this.Flag + "]";
+ };
+ return Rule;
+ })();
+ Formatting.Rule = Rule;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ (function (RuleAction) {
+ RuleAction._map = [];
+ RuleAction._map[0] = "Ignore";
+ RuleAction.Ignore = 0;
+ RuleAction._map[1] = "Space";
+ RuleAction.Space = 1;
+ RuleAction._map[2] = "NewLine";
+ RuleAction.NewLine = 2;
+ RuleAction._map[3] = "Delete";
+ RuleAction.Delete = 3;
+ })(Formatting.RuleAction || (Formatting.RuleAction = {}));
+ var RuleAction = Formatting.RuleAction;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var RuleDescriptor = (function () {
+ function RuleDescriptor(LeftTokenRange, RightTokenRange) {
+ this.LeftTokenRange = LeftTokenRange;
+ this.RightTokenRange = RightTokenRange;
+ }
+ RuleDescriptor.prototype.toString = function () {
+ return "[leftRange=" + this.LeftTokenRange + "," + "rightRange=" + this.RightTokenRange + "]";
+ };
+ RuleDescriptor.create1 = function create1(left, right) {
+ return RuleDescriptor.create4(Formatting.Shared.TokenRange.FromToken(left), Formatting.Shared.TokenRange.FromToken(right));
+ };
+ RuleDescriptor.create2 = function create2(left, right) {
+ return RuleDescriptor.create4(left, Formatting.Shared.TokenRange.FromToken(right));
+ };
+ RuleDescriptor.create3 = function create3(left, right) {
+ return RuleDescriptor.create4(Formatting.Shared.TokenRange.FromToken(left), right);
+ };
+ RuleDescriptor.create4 = function create4(left, right) {
+ return new RuleDescriptor(left, right);
+ };
+ return RuleDescriptor;
+ })();
+ Formatting.RuleDescriptor = RuleDescriptor;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ (function (RuleFlags) {
+ RuleFlags._map = [];
+ RuleFlags._map[0] = "None";
+ RuleFlags.None = 0;
+ RuleFlags._map[1] = "CanDeleteNewLines";
+ RuleFlags.CanDeleteNewLines = 1;
+ })(Formatting.RuleFlags || (Formatting.RuleFlags = {}));
+ var RuleFlags = Formatting.RuleFlags;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var RuleOperation = (function () {
+ function RuleOperation() {
+ this.Context = null;
+ this.Action = null;
+ }
+ RuleOperation.prototype.toString = function () {
+ return "[context=" + this.Context + "," + "action=" + this.Action + "]";
+ };
+ RuleOperation.create1 = function create1(action) {
+ return RuleOperation.create2(Formatting.RuleOperationContext.Any, action);
+ };
+ RuleOperation.create2 = function create2(context, action) {
+ var result = new RuleOperation();
+ result.Context = context;
+ result.Action = action;
+ return result;
+ };
+ return RuleOperation;
+ })();
+ Formatting.RuleOperation = RuleOperation;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var RuleOperationContext = (function () {
+ function RuleOperationContext() {
+ var funcs = [];
+ for (var _i = 0; _i < (arguments.length - 0); _i++) {
+ funcs[_i] = arguments[_i + 0];
+ }
+ this.customContextChecks = funcs;
+ }
+ RuleOperationContext.Any = new RuleOperationContext();
+ RuleOperationContext.prototype.IsAny = function () {
+ {
+ return this == RuleOperationContext.Any;
+ }
+ };
+ RuleOperationContext.prototype.InContext = function (context) {
+ if(this.IsAny()) {
+ return true;
+ }
+ for(var i = 0, len = this.customContextChecks.length; i < len; i++) {
+ if(!this.customContextChecks[i](context)) {
+ return false;
+ }
+ }
+ return true;
+ };
+ return RuleOperationContext;
+ })();
+ Formatting.RuleOperationContext = RuleOperationContext;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var Rules = (function () {
+ function Rules() {
+ this.IgnoreBeforeComment = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkComment), Formatting.RuleOperation.create1(Formatting.RuleAction.Ignore));
+ this.IgnoreAfterLineComment = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkComment, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFirstTokenLineCommentContext), Formatting.RuleAction.Ignore));
+ this.NoSpaceBeforeSemicolon = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkSColon), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotForContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeColon = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkColon), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeQMark = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkQMark), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterColon = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkColon, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterQMark = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkQMark, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterSemicolon = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkSColon, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NewLineAfterCloseCurly = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkRCurly, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsMultilineChildParentContext), Formatting.RuleAction.NewLine));
+ this.SpaceAfterCloseCurly = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkRCurly, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineSiblingNodeContext), Formatting.RuleAction.Space));
+ this.SpaceBetweenCloseCurlyAndElse = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkRCurly, Formatting.AuthorTokenKind.atkElse), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.SpaceBetweenCloseCurlyAndWhile = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkRCurly, Formatting.AuthorTokenKind.atkWhile), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NoSpaceBeforeDot = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkDot), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterDot = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkDot, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeOpenBracket = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkLBrack), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterOpenBracket = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkLBrack, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeCloseBracket = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkRBrack), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterCloseBracket = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkRBrack, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterOpenCurly = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkLCurly, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), Formatting.RuleAction.Space));
+ this.SpaceBeforeCloseCurly = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkRCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), Formatting.RuleAction.Space));
+ this.NoSpaceBetweenEmptyCurlyBrackets = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkLCurly, Formatting.AuthorTokenKind.atkRCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsObjectContext), Formatting.RuleAction.Delete));
+ this.NewLineAfterOpenCurlyInBlockContext = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkLCurly, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsMultilineBlockContext), Formatting.RuleAction.NewLine));
+ this.NewLineBeforeCloseCurlyInFunctionOrControl = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkRCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsMultilineBlockContext), Formatting.RuleAction.NewLine));
+ this.NoSpaceAfterUnaryPrefixOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.UnaryPrefixOperators, Formatting.Shared.TokenRange.UnaryPrefixExpressions), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterUnaryPreincrementOperator = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkInc, Formatting.Shared.TokenRange.UnaryPreincrementExpressions), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterUnaryPredecrementOperator = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkDec, Formatting.Shared.TokenRange.UnaryPredecrementExpressions), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeUnaryPostincrementOperator = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.UnaryPostincrementExpressions, Formatting.AuthorTokenKind.atkInc), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeUnaryPostdecrementOperator = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.UnaryPostdecrementExpressions, Formatting.AuthorTokenKind.atkDec), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterPostincrementWhenFollowedByAdd = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkInc, Formatting.AuthorTokenKind.atkAdd), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterAddWhenFollowedByUnaryPlus = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkAdd, Formatting.AuthorTokenKind.atkAdd), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterAddWhenFollowedByPreincrement = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkAdd, Formatting.AuthorTokenKind.atkInc), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterPostdecrementWhenFollowedBySubtract = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkDec, Formatting.AuthorTokenKind.atkSub), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterSubtractWhenFollowedByUnaryMinus = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkSub, Formatting.AuthorTokenKind.atkSub), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterSubtractWhenFollowedByPredecrement = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkSub, Formatting.AuthorTokenKind.atkDec), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.NoSpaceBeforeComma = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkComma), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterCertainKeywords = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkVar,
+ Formatting.AuthorTokenKind.atkThrow,
+ Formatting.AuthorTokenKind.atkNew,
+ Formatting.AuthorTokenKind.atkDelete,
+ Formatting.AuthorTokenKind.atkReturn,
+ Formatting.AuthorTokenKind.atkVoid,
+ Formatting.AuthorTokenKind.atkTypeof
+ ]), Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NoSpaceBeforeOpenParenInFuncCall = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionCallOrNewContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterFunctionInFuncDecl = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkFunction, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFunctionDeclContext), Formatting.RuleAction.Space));
+ this.NoSpaceBeforeOpenParenInFuncDecl = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionOrGetSetDeclContext), Formatting.RuleAction.Delete));
+ this.SpaceBetweenStatements = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkDo,
+ Formatting.AuthorTokenKind.atkElse,
+ Formatting.AuthorTokenKind.atkCase
+ ]), Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotForContext), Formatting.RuleAction.Space));
+ this.SpaceAfterTryFinally = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkTry,
+ Formatting.AuthorTokenKind.atkFinally
+ ]), Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.SpaceAfterGetSetInMember = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkIdentifier, Formatting.AuthorTokenKind.atkIdentifier), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsGetSetMemberContext), Formatting.RuleAction.Space));
+ this.SpaceBeforeBinaryKeywordOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.Any, Formatting.Shared.TokenRange.BinaryKeywordOperators), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterBinaryKeywordOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.BinaryKeywordOperators, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterConstructor = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkConstructor, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterModuleImport = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkModule, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterCertainTypeScriptKeywords = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkClass,
+ Formatting.AuthorTokenKind.atkDeclare,
+ Formatting.AuthorTokenKind.atkEnum,
+ Formatting.AuthorTokenKind.atkExport,
+ Formatting.AuthorTokenKind.atkExtends,
+ Formatting.AuthorTokenKind.atkGet,
+ Formatting.AuthorTokenKind.atkImplements,
+ Formatting.AuthorTokenKind.atkImport,
+ Formatting.AuthorTokenKind.atkInterface,
+ Formatting.AuthorTokenKind.atkModule,
+ Formatting.AuthorTokenKind.atkPrivate,
+ Formatting.AuthorTokenKind.atkPublic,
+ Formatting.AuthorTokenKind.atkSet,
+ Formatting.AuthorTokenKind.atkStatic
+ ]), Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.SpaceBeforeCertainTypeScriptKeywords = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.Any, Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkExtends,
+ Formatting.AuthorTokenKind.atkImplements
+ ])), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.SpaceAfterModuleName = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkString, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsModuleDeclContext), Formatting.RuleAction.Space));
+ this.SpaceAfterArrow = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkArrow, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterEllipsis = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkEllipsis, Formatting.AuthorTokenKind.atkIdentifier), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterOptionalParameters = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkQMark, Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkComma
+ ])), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBetweenEmptyInterfaceCurlyBrackets = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkLCurly, Formatting.AuthorTokenKind.atkRCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsInterfaceContext), Formatting.RuleAction.Delete));
+ this.HighPriorityCommonRules = [
+ this.IgnoreBeforeComment,
+ this.IgnoreAfterLineComment,
+ this.NoSpaceBeforeSemicolon,
+ this.NoSpaceBeforeColon,
+ this.SpaceAfterColon,
+ this.NoSpaceBeforeQMark,
+ this.SpaceAfterQMark,
+ this.NewLineAfterCloseCurly,
+ this.NoSpaceBeforeDot,
+ this.NoSpaceAfterDot,
+ this.NoSpaceAfterUnaryPrefixOperator,
+ this.NoSpaceAfterUnaryPreincrementOperator,
+ this.NoSpaceAfterUnaryPredecrementOperator,
+ this.NoSpaceBeforeUnaryPostincrementOperator,
+ this.NoSpaceBeforeUnaryPostdecrementOperator,
+ this.SpaceAfterPostincrementWhenFollowedByAdd,
+ this.SpaceAfterAddWhenFollowedByUnaryPlus,
+ this.SpaceAfterAddWhenFollowedByPreincrement,
+ this.SpaceAfterPostdecrementWhenFollowedBySubtract,
+ this.SpaceAfterSubtractWhenFollowedByUnaryMinus,
+ this.SpaceAfterSubtractWhenFollowedByPredecrement,
+ this.SpaceAfterOpenCurly,
+ this.SpaceBeforeCloseCurly,
+ this.SpaceAfterCloseCurly,
+ this.SpaceBetweenCloseCurlyAndElse,
+ this.SpaceBetweenCloseCurlyAndWhile,
+ this.NoSpaceBetweenEmptyCurlyBrackets,
+ this.NewLineBeforeCloseCurlyInFunctionOrControl,
+ this.SpaceAfterFunctionInFuncDecl,
+ this.NewLineAfterOpenCurlyInBlockContext,
+ this.SpaceAfterGetSetInMember,
+ this.SpaceAfterCertainKeywords,
+ this.NoSpaceBeforeOpenParenInFuncCall,
+ this.SpaceBeforeBinaryKeywordOperator,
+ this.SpaceAfterBinaryKeywordOperator,
+ this.NoSpaceAfterConstructor,
+ this.NoSpaceAfterModuleImport,
+ this.SpaceAfterCertainTypeScriptKeywords,
+ this.SpaceBeforeCertainTypeScriptKeywords,
+ this.SpaceAfterModuleName,
+ this.SpaceAfterArrow,
+ this.NoSpaceAfterEllipsis,
+ this.NoSpaceAfterOptionalParameters,
+ this.NoSpaceBetweenEmptyInterfaceCurlyBrackets,
+
+ ];
+ this.LowPriorityCommonRules = [
+ this.NoSpaceBeforeComma,
+ this.NoSpaceBeforeOpenBracket,
+ this.NoSpaceAfterOpenBracket,
+ this.NoSpaceBeforeCloseBracket,
+ this.NoSpaceAfterCloseBracket,
+ this.SpaceAfterSemicolon,
+ this.NoSpaceBeforeOpenParenInFuncDecl,
+ this.SpaceBetweenStatements,
+ this.SpaceAfterTryFinally
+ ];
+ this.SpaceAfterComma = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkComma, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterComma = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkComma, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceBeforeBinaryOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.Any, Formatting.Shared.TokenRange.BinaryOperators), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterBinaryOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.BinaryOperators, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.NoSpaceBeforeBinaryOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.Any, Formatting.Shared.TokenRange.BinaryOperators), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterBinaryOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.BinaryOperators, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterKeywordInControl = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Keywords, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsControlDeclContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterKeywordInControl = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Keywords, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsControlDeclContext), Formatting.RuleAction.Delete));
+ this.FunctionOpenCurlyLeftTokenRange = Formatting.Shared.TokenRange.Any;
+ this.FunctionOpenCurlyLeftTokenRange_Js = Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkComment
+ ]);
+ this.SpaceBeforeOpenCurlyInFunction = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.FunctionOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrMultilineBlockContext), Formatting.RuleAction.Space), Formatting.RuleFlags.CanDeleteNewLines);
+ this.NewLineBeforeOpenCurlyInFunction = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.FunctionOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsMultilineBlockContext), Formatting.RuleAction.NewLine), Formatting.RuleFlags.CanDeleteNewLines);
+ this.TypeScriptOpenCurlyLeftTokenRange = Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkComment
+ ]);
+ this.SpaceBeforeOpenCurlyInTypeScriptDeclWithBlock = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.TypeScriptOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrMultilineBlockContext), Formatting.RuleAction.Space), Formatting.RuleFlags.CanDeleteNewLines);
+ this.NewLineBeforeOpenCurlyInTypeScriptDeclWithBlock = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.TypeScriptOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsMultilineBlockContext), Formatting.RuleAction.NewLine), Formatting.RuleFlags.CanDeleteNewLines);
+ this.ControlOpenCurlyLeftTokenRange = Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkComment,
+ Formatting.AuthorTokenKind.atkDo,
+ Formatting.AuthorTokenKind.atkTry,
+ Formatting.AuthorTokenKind.atkFinally,
+ Formatting.AuthorTokenKind.atkElse
+ ]);
+ this.SpaceBeforeOpenCurlyInControl = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.ControlOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrMultilineBlockContext), Formatting.RuleAction.Space), Formatting.RuleFlags.CanDeleteNewLines);
+ this.NewLineBeforeOpenCurlyInControl = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.ControlOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsMultilineBlockContext), Formatting.RuleAction.NewLine), Formatting.RuleFlags.CanDeleteNewLines);
+ this.SpaceAfterSemicolonInFor = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkSColon, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsForContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterSemicolonInFor = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkSColon, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsForContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterOpenParen = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkLParen, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.SpaceBeforeCloseParen = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkRParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NoSpaceBetweenParens = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkLParen, Formatting.AuthorTokenKind.atkRParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterOpenParen = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkLParen, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeCloseParen = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkRParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterAnonymousFunctionKeyword = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkFunction, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFunctionDeclContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterAnonymousFunctionKeyword = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkFunction, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFunctionDeclContext), Formatting.RuleAction.Delete));
+ }
+ Rules.prototype.getRuleName = function (rule) {
+ var o = this;
+ for(var name in o) {
+ if(o[name] === rule) {
+ return name;
+ }
+ }
+ throw new Error("Unknown rule");
+ };
+ Rules.IsForContext = function IsForContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFor;
+ };
+ Rules.IsNotForContext = function IsNotForContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkFor;
+ };
+ Rules.IsBinaryOpContext = function IsBinaryOpContext(context) {
+ if(context.contextNode.AuthorNode.Details.ast != null) {
+ switch(context.contextNode.AuthorNode.Details.ast.nodeType) {
+ case TypeScript.NodeType.ImportDeclaration:
+ return true;
+ }
+ }
+ switch(context.contextNode.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkAdd:
+ case Formatting.AuthorParseNodeKind.apnkSub:
+ case Formatting.AuthorParseNodeKind.apnkMul:
+ case Formatting.AuthorParseNodeKind.apnkDiv:
+ case Formatting.AuthorParseNodeKind.apnkMod:
+ case Formatting.AuthorParseNodeKind.apnkOr:
+ case Formatting.AuthorParseNodeKind.apnkXor:
+ case Formatting.AuthorParseNodeKind.apnkAnd:
+ case Formatting.AuthorParseNodeKind.apnkEq:
+ case Formatting.AuthorParseNodeKind.apnkNe:
+ case Formatting.AuthorParseNodeKind.apnkLt:
+ case Formatting.AuthorParseNodeKind.apnkLe:
+ case Formatting.AuthorParseNodeKind.apnkGe:
+ case Formatting.AuthorParseNodeKind.apnkGt:
+ case Formatting.AuthorParseNodeKind.apnkAsg:
+ case Formatting.AuthorParseNodeKind.apnkInstOf:
+ case Formatting.AuthorParseNodeKind.apnkIn:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkEqv:
+ case Formatting.AuthorParseNodeKind.apnkNEqv:
+ case Formatting.AuthorParseNodeKind.apnkLogOr:
+ case Formatting.AuthorParseNodeKind.apnkLogAnd:
+ case Formatting.AuthorParseNodeKind.apnkLsh:
+ case Formatting.AuthorParseNodeKind.apnkRsh:
+ case Formatting.AuthorParseNodeKind.apnkRs2:
+ case Formatting.AuthorParseNodeKind.apnkQmark:
+ case Formatting.AuthorParseNodeKind.apnkAsgAdd:
+ case Formatting.AuthorParseNodeKind.apnkAsgSub:
+ case Formatting.AuthorParseNodeKind.apnkAsgMul:
+ case Formatting.AuthorParseNodeKind.apnkAsgDiv:
+ case Formatting.AuthorParseNodeKind.apnkAsgMod:
+ case Formatting.AuthorParseNodeKind.apnkAsgAnd:
+ case Formatting.AuthorParseNodeKind.apnkAsgXor:
+ case Formatting.AuthorParseNodeKind.apnkAsgOr:
+ case Formatting.AuthorParseNodeKind.apnkAsgLsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRs2:
+ return true;
+ case Formatting.AuthorParseNodeKind.apnkVarDecl:
+ var varOrArgDecl = context.contextNode.AuthorNode.Details.ast;
+ var tokenSpan = null;
+ if(context.tokenSpan.tokenID === TypeScript.TokenID.Question) {
+ tokenSpan = context.tokenSpan.Span.span;
+ } else if(context.nextTokenSpan.tokenID === TypeScript.TokenID.Question) {
+ tokenSpan = context.nextTokenSpan.Span.span;
+ }
+ if(context.tokenSpan.tokenID === TypeScript.TokenID.Colon) {
+ tokenSpan = context.tokenSpan.Span.span;
+ } else if(context.nextTokenSpan.tokenID === TypeScript.TokenID.Colon) {
+ tokenSpan = context.nextTokenSpan.Span.span;
+ }
+ if(tokenSpan != null) {
+ if(varOrArgDecl != null && (varOrArgDecl.nodeType === TypeScript.NodeType.VarDecl || varOrArgDecl.nodeType === TypeScript.NodeType.ArgDecl)) {
+ if(TypeScript.isValidAstNode(varOrArgDecl)) {
+ if(!TypeScript.isValidAstNode(varOrArgDecl.init)) {
+ return false;
+ }
+ var initSpan = Formatting.Span.FromBounds(varOrArgDecl.init.minChar, varOrArgDecl.init.limChar);
+ return initSpan.Contains(tokenSpan);
+ }
+ }
+ }
+ return true;
+ case Formatting.AuthorParseNodeKind.apnkFncDecl:
+ var fncDecl = context.contextNode.AuthorNode.Details.ast;
+ if(context.tokenSpan.tokenID === TypeScript.TokenID.EqualsGreaterThan || context.nextTokenSpan.tokenID === TypeScript.TokenID.EqualsGreaterThan) {
+ if(fncDecl != null && TypeScript.hasFlag(fncDecl.fncFlags, TypeScript.FncFlags.IsFunctionExpression)) {
+ return true;
+ }
+ }
+ break;
+ default:
+ return false;
+ }
+ };
+ Rules.IsNotBinaryOpContext = function IsNotBinaryOpContext(context) {
+ return !Rules.IsBinaryOpContext(context);
+ };
+ Rules.IsBlockContext = function IsBlockContext(node) {
+ if(Rules.IsTypeScriptDeclWithBlockContextNode(node)) {
+ return true;
+ }
+ switch(node.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkBlock:
+ case Formatting.AuthorParseNodeKind.apnkList:
+ case Formatting.AuthorParseNodeKind.apnkObject:
+ case Formatting.AuthorParseNodeKind.apnkFncDecl:
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ case Formatting.AuthorParseNodeKind.apnkIf:
+ case Formatting.AuthorParseNodeKind.apnkWhile:
+ case Formatting.AuthorParseNodeKind.apnkDoWhile:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkWith:
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ case Formatting.AuthorParseNodeKind.apnkTryCatch:
+ case Formatting.AuthorParseNodeKind.apnkCatch:
+ case Formatting.AuthorParseNodeKind.apnkTry:
+ case Formatting.AuthorParseNodeKind.apnkFinally:
+ case Formatting.AuthorParseNodeKind.apnkTryFinally:
+ return true;
+ default:
+ return false;
+ }
+ };
+ Rules.IsTypeScriptDeclWithBlockContextNode = function IsTypeScriptDeclWithBlockContextNode(node) {
+ switch(node.AuthorNode.Details.nodeType) {
+ case TypeScript.NodeType.ModuleDeclaration:
+ case TypeScript.NodeType.InterfaceDeclaration:
+ case TypeScript.NodeType.ClassDeclaration:
+ return true;
+ default:
+ return false;
+ }
+ };
+ Rules.IsSingleLineBlockContext = function IsSingleLineBlockContext(context) {
+ if(!Rules.IsBlockContext(context.contextNode)) {
+ return false;
+ }
+ return context.ContextNodeAllOnSameLine();
+ };
+ Rules.IsMultilineBlockContext = function IsMultilineBlockContext(context) {
+ if(!Rules.IsBlockContext(context.contextNode)) {
+ return false;
+ }
+ return !context.ContextNodeAllOnSameLine();
+ };
+ Rules.IsFunctionDeclContext = function IsFunctionDeclContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl;
+ };
+ Rules.IsTypeScriptDeclWithBlockContext = function IsTypeScriptDeclWithBlockContext(context) {
+ return Rules.IsTypeScriptDeclWithBlockContextNode(context.contextNode);
+ };
+ Rules.IsControlDeclContext = function IsControlDeclContext(context) {
+ switch(context.contextNode.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ case Formatting.AuthorParseNodeKind.apnkIf:
+ case Formatting.AuthorParseNodeKind.apnkWhile:
+ case Formatting.AuthorParseNodeKind.apnkDoWhile:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkWith:
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ case Formatting.AuthorParseNodeKind.apnkTryCatch:
+ case Formatting.AuthorParseNodeKind.apnkCatch:
+ case Formatting.AuthorParseNodeKind.apnkTry:
+ case Formatting.AuthorParseNodeKind.apnkFinally:
+ case Formatting.AuthorParseNodeKind.apnkTryFinally:
+ return true;
+ default:
+ return false;
+ }
+ };
+ Rules.IsObjectContext = function IsObjectContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkObject;
+ };
+ Rules.IsFunctionCallContext = function IsFunctionCallContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkCall;
+ };
+ Rules.IsNewContext = function IsNewContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkNew;
+ };
+ Rules.IsFunctionCallOrNewContext = function IsFunctionCallOrNewContext(context) {
+ return Rules.IsFunctionCallContext(context) || Rules.IsNewContext(context);
+ };
+ Rules.IsSameLineTokenContext = function IsSameLineTokenContext(context) {
+ return context.TokensAreOnSameLine();
+ };
+ Rules.IsSameLineSiblingNodeContext = function IsSameLineSiblingNodeContext(context) {
+ return context.TokensAreSiblingNodesOnSameLine();
+ };
+ Rules.IsMultilineChildParentContext = function IsMultilineChildParentContext(context) {
+ var parent = context.contextNode.Parent;
+ if(parent == null) {
+ return false;
+ }
+ return parent.AuthorNode.Details.EndOffset == context.nextTokenSpan.Span.startPosition() && Rules.IsMultilineBlockContext(context);
+ };
+ Rules.IsNotFormatOnEnter = function IsNotFormatOnEnter(context) {
+ return context.formattingRequestKind != Formatting.FormattingRequestKind.FormatOnEnter;
+ };
+ Rules.IsSameLineTokenOrMultilineBlockContext = function IsSameLineTokenOrMultilineBlockContext(context) {
+ return context.TokensAreOnSameLine() || Rules.IsMultilineBlockContext(context);
+ };
+ Rules.IsFunctionOrGetSetDeclContext = function IsFunctionOrGetSetDeclContext(context) {
+ return Rules.IsFunctionDeclContext(context) || Rules.IsGetSetMemberContext(context);
+ };
+ Rules.IsGetSetMemberContext = function IsGetSetMemberContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkGetMember || context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkSetMember;
+ };
+ Rules.IsFirstTokenLineCommentContext = function IsFirstTokenLineCommentContext(context) {
+ var token = context.tokenSpan;
+ var twoCharSpan = token.Span.Intersection(new Formatting.Span(token.Span.startPosition(), 2));
+ return twoCharSpan != null && twoCharSpan.GetText() == "//";
+ };
+ Rules.IsModuleDeclContext = function IsModuleDeclContext(context) {
+ return context.contextNode.AuthorNode.Details.nodeType == TypeScript.NodeType.ModuleDeclaration;
+ };
+ Rules.IsInterfaceContext = function IsInterfaceContext(context) {
+ return context.contextNode.AuthorNode.Details.nodeType == TypeScript.NodeType.List && context.contextNode.Parent != null && context.contextNode.Parent.AuthorNode.Details.nodeType == TypeScript.NodeType.InterfaceDeclaration;
+ };
+ return Rules;
+ })();
+ Formatting.Rules = Rules;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var RulesMap = (function () {
+ function RulesMap() {
+ this.map = [];
+ this.mapRowLength = 0;
+ }
+ RulesMap.create = function create(rules) {
+ var result = new RulesMap();
+ result.Initialize(rules);
+ return result;
+ };
+ RulesMap.prototype.Initialize = function (rules) {
+ this.mapRowLength = Formatting.AuthorTokenKind.Length;
+ this.map = new Array(this.mapRowLength * this.mapRowLength);
+ var rulesBucketConstructionStateList = new Array(this.map.length);
+ this.FillRules(rules, rulesBucketConstructionStateList);
+ return this.map;
+ };
+ RulesMap.prototype.FillRules = function (rules, rulesBucketConstructionStateList) {
+ var _this = this;
+ rules.foreach(function (rule) {
+ _this.FillRule(rule, rulesBucketConstructionStateList);
+ });
+ };
+ RulesMap.prototype.GetRuleBucketIndex = function (row, column) {
+ var rulesBucketIndex = (row * this.mapRowLength) + column;
+ return rulesBucketIndex;
+ };
+ RulesMap.prototype.FillRule = function (rule, rulesBucketConstructionStateList) {
+ var _this = this;
+ var specificRule = rule.Descriptor.LeftTokenRange != Formatting.Shared.TokenRange.Any && rule.Descriptor.RightTokenRange != Formatting.Shared.TokenRange.Any;
+ rule.Descriptor.LeftTokenRange.GetTokens().foreach(function (left) {
+ rule.Descriptor.RightTokenRange.GetTokens().foreach(function (right) {
+ var rulesBucketIndex = _this.GetRuleBucketIndex(left, right);
+ var rulesBucket = _this.map[rulesBucketIndex];
+ if(rulesBucket == undefined) {
+ rulesBucket = _this.map[rulesBucketIndex] = new RulesBucket();
+ }
+ rulesBucket.AddRule(rule, specificRule, rulesBucketConstructionStateList, rulesBucketIndex);
+ });
+ });
+ };
+ RulesMap.prototype.GetRule = function (context) {
+ var bucketIndex = this.GetRuleBucketIndex(context.tokenSpan.Token, context.nextTokenSpan.Token);
+ var bucket = this.map[bucketIndex];
+ if(bucket != null) {
+ for(var i = 0, len = bucket.Rules().count(); i < len; i++) {
+ var rule = bucket.Rules().get(i);
+ if(rule.Operation.Context.InContext(context)) {
+ return rule;
+ }
+ }
+ }
+ return null;
+ };
+ return RulesMap;
+ })();
+ Formatting.RulesMap = RulesMap;
+ var MaskBitSize = 5;
+ var Mask = 0x1f;
+ (function (Position) {
+ Position._map = [];
+ Position.IgnoreRulesSpecific = 0;
+ Position.IgnoreRulesAny = MaskBitSize * 1;
+ Position.ContextRulesSpecific = MaskBitSize * 2;
+ Position.ContextRulesAny = MaskBitSize * 3;
+ Position.NoContextRulesSpecific = MaskBitSize * 4;
+ Position.NoContextRulesAny = MaskBitSize * 5;
+ })(Formatting.Position || (Formatting.Position = {}));
+ var Position = Formatting.Position;
+ var RulesBucketConstructionState = (function () {
+ function RulesBucketConstructionState() {
+ this.rulesInsertionIndexBitmap = 0;
+ }
+ RulesBucketConstructionState.prototype.GetInsertionIndex = function (maskPosition) {
+ var index = 0;
+ var pos = 0;
+ var indexBitmap = this.rulesInsertionIndexBitmap;
+ while(pos <= maskPosition) {
+ index += (indexBitmap & Mask);
+ indexBitmap >>= MaskBitSize;
+ pos += MaskBitSize;
+ }
+ return index;
+ };
+ RulesBucketConstructionState.prototype.IncreaseInsertionIndex = function (maskPosition) {
+ var value = (this.rulesInsertionIndexBitmap >> maskPosition) & Mask;
+ value++;
+ Formatting.Debug.Assert((value & Mask) == value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules.");
+ var temp = this.rulesInsertionIndexBitmap & ~(Mask << maskPosition);
+ temp |= value << maskPosition;
+ this.rulesInsertionIndexBitmap = temp;
+ };
+ return RulesBucketConstructionState;
+ })();
+ Formatting.RulesBucketConstructionState = RulesBucketConstructionState;
+ var RulesBucket = (function () {
+ function RulesBucket() {
+ this.rules = new Formatting.List_Rule();
+ }
+ RulesBucket.prototype.Rules = function () {
+ return this.rules;
+ };
+ RulesBucket.prototype.AddRule = function (rule, specificTokens, constructionState, rulesBucketIndex) {
+ var position;
+ if(rule.Operation.Action == Formatting.RuleAction.Ignore) {
+ position = specificTokens ? Position.IgnoreRulesSpecific : Position.IgnoreRulesAny;
+ } else if(!rule.Operation.Context.IsAny()) {
+ position = specificTokens ? Position.ContextRulesSpecific : Position.ContextRulesAny;
+ } else {
+ position = specificTokens ? Position.NoContextRulesSpecific : Position.NoContextRulesAny;
+ }
+ var state = constructionState[rulesBucketIndex];
+ if(state === undefined) {
+ state = constructionState[rulesBucketIndex] = new RulesBucketConstructionState();
+ }
+ var index = state.GetInsertionIndex(position);
+ this.rules.insert(index, rule);
+ state.IncreaseInsertionIndex(position);
+ };
+ return RulesBucket;
+ })();
+ Formatting.RulesBucket = RulesBucket;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var RulesProvider = (function () {
+ function RulesProvider(logger) {
+ this.logger = logger;
+ this.globalRules = new Formatting.Rules();
+ }
+ RulesProvider.prototype.getRuleName = function (rule) {
+ return this.globalRules.getRuleName(rule);
+ };
+ RulesProvider.prototype.getRuleByName = function (name) {
+ return this.globalRules[name];
+ };
+ RulesProvider.prototype.setActiveRules = function (staticList) {
+ this.activeRules = staticList;
+ this.rulesMap = Formatting.RulesMap.create(this.activeRules);
+ };
+ RulesProvider.prototype.getActiveRules = function () {
+ return this.activeRules;
+ };
+ RulesProvider.prototype.getRulesMap = function () {
+ return this.rulesMap;
+ };
+ RulesProvider.prototype.ensureUptodate = function (options) {
+ var _this = this;
+ if(this.options == null || !Services.compareDataObjects(this.options, options)) {
+ var activeRules = TypeScript.timeFunction(this.logger, "RulesProvider: createActiveRules()", function () {
+ return _this.createActiveRules(options);
+ });
+ var rulesMap = TypeScript.timeFunction(this.logger, "RulesProvider: RulesMap.create()", function () {
+ return Formatting.RulesMap.create(activeRules);
+ });
+ this.activeRules = activeRules;
+ this.rulesMap = rulesMap;
+ this.options = options;
+ }
+ };
+ RulesProvider.prototype.createActiveRules = function (options) {
+ var rules = new Formatting.List_Rule();
+ rules.AddRange(this.globalRules.HighPriorityCommonRules);
+ if(options.InsertSpaceAfterCommaDelimiter) {
+ rules.Add(this.globalRules.SpaceAfterComma);
+ } else {
+ rules.Add(this.globalRules.NoSpaceAfterComma);
+ }
+ if(options.InsertSpaceAfterFunctionKeywordForAnonymousFunctions) {
+ rules.Add(this.globalRules.SpaceAfterAnonymousFunctionKeyword);
+ } else {
+ rules.Add(this.globalRules.NoSpaceAfterAnonymousFunctionKeyword);
+ }
+ if(options.InsertSpaceAfterKeywordsInControlFlowStatements) {
+ rules.Add(this.globalRules.SpaceAfterKeywordInControl);
+ } else {
+ rules.Add(this.globalRules.NoSpaceAfterKeywordInControl);
+ }
+ if(options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis) {
+ rules.Add(this.globalRules.SpaceAfterOpenParen);
+ rules.Add(this.globalRules.SpaceBeforeCloseParen);
+ rules.Add(this.globalRules.NoSpaceBetweenParens);
+ } else {
+ rules.Add(this.globalRules.NoSpaceAfterOpenParen);
+ rules.Add(this.globalRules.NoSpaceBeforeCloseParen);
+ rules.Add(this.globalRules.NoSpaceBetweenParens);
+ }
+ if(options.InsertSpaceAfterSemicolonInForStatements) {
+ rules.Add(this.globalRules.SpaceAfterSemicolonInFor);
+ } else {
+ rules.Add(this.globalRules.NoSpaceAfterSemicolonInFor);
+ }
+ if(options.InsertSpaceBeforeAndAfterBinaryOperators) {
+ rules.Add(this.globalRules.SpaceBeforeBinaryOperator);
+ rules.Add(this.globalRules.SpaceAfterBinaryOperator);
+ } else {
+ rules.Add(this.globalRules.NoSpaceBeforeBinaryOperator);
+ rules.Add(this.globalRules.NoSpaceAfterBinaryOperator);
+ }
+ if(options.PlaceOpenBraceOnNewLineForControlBlocks) {
+ rules.Add(this.globalRules.NewLineBeforeOpenCurlyInControl);
+ } else {
+ rules.Add(this.globalRules.SpaceBeforeOpenCurlyInControl);
+ }
+ if(options.PlaceOpenBraceOnNewLineForFunctions) {
+ rules.Add(this.globalRules.NewLineBeforeOpenCurlyInFunction);
+ rules.Add(this.globalRules.NewLineBeforeOpenCurlyInTypeScriptDeclWithBlock);
+ } else {
+ rules.Add(this.globalRules.SpaceBeforeOpenCurlyInFunction);
+ rules.Add(this.globalRules.SpaceBeforeOpenCurlyInTypeScriptDeclWithBlock);
+ }
+ rules.AddRange(this.globalRules.LowPriorityCommonRules);
+ return rules;
+ };
+ return RulesProvider;
+ })();
+ Formatting.RulesProvider = RulesProvider;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var SmartIndentManager = (function () {
+ function SmartIndentManager(scriptSyntaxAST, editorOptions) {
+ this.scriptSyntaxAST = scriptSyntaxAST;
+ this.editorOptions = editorOptions;
+ this.logger = new TypeScript.LoggerAdapter(this.scriptSyntaxAST.getLogger());
+ this.sourceText = this.scriptSyntaxAST.getSourceText();
+ this.snapshot = new Formatting.TextSnapshot(this.scriptSyntaxAST.getScript(), this.sourceText);
+ this.fileAuthoringProxy = new Formatting.FileAuthoringProxy(this.scriptSyntaxAST);
+ this.tokenKindMap = Formatting.AuthorTokenKindMap.getInstance();
+ }
+ SmartIndentManager.prototype.getSmartIndentAtLineNumber = function (lineNumber) {
+ var line = this.snapshot.GetLineFromLineNumber(lineNumber);
+ var caretPosition = new Formatting.SnapshotSpan(this.snapshot, new Formatting.Span(line.startPosition(), 0));
+ var tokensSpan = this.getPossibleTokenSpan(caretPosition);
+ var tokens = this.gtTokens(tokensSpan);
+ var languageHostIndentation = null;
+ var task = new Formatting.SmartIndentTask(this.logger, caretPosition, tokens, this.fileAuthoringProxy, this.editorOptions, languageHostIndentation);
+ task.Run();
+ if(task.DesiredIndentation === null) {
+ return this.getBlockIndent(line);
+ } else {
+ return Formatting.Indenter.GetIndentSizeFromIndentText(task.DesiredIndentation, this.editorOptions);
+ }
+ };
+ SmartIndentManager.prototype.getPossibleTokenSpan = function (caretPosition) {
+ var startPosition = caretPosition.start().GetContainingLine().startPosition();
+ var endPosition = caretPosition.start().GetContainingLine().endPosition();
+ endPosition = Formatting.Math.Min(endPosition, startPosition + 100);
+ return new Formatting.SnapshotSpan(caretPosition.snapshot, Formatting.Span.FromBounds(startPosition, endPosition));
+ };
+ SmartIndentManager.prototype.gtTokens = function (span) {
+ return Formatting.getTokensInSpan(this.logger, this.scriptSyntaxAST, this.tokenKindMap, span);
+ };
+ SmartIndentManager.prototype.getBlockIndent = function (line) {
+ var previousLine = null;
+ for(var lineNumber = line.lineNumber() - 1; lineNumber >= 0; --lineNumber) {
+ previousLine = line.snapshot().GetLineFromLineNumber(lineNumber);
+ var text = previousLine.getText();
+ if(text.length > 0) {
+ return Formatting.Indenter.GetIndentSizeFromIndentText(text, this.editorOptions);
+ }
+ }
+ return null;
+ };
+ return SmartIndentManager;
+ })();
+ Formatting.SmartIndentManager = SmartIndentManager;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var SmartIndentTask = (function () {
+ function SmartIndentTask(logger, snapshotSpan, tokens, fileAuthoringProxy, editorOptions, languageHostIndentation) {
+ this.logger = logger;
+ this.snapshotSpan = snapshotSpan;
+ this.tokens = tokens;
+ this.fileAuthoringProxy = fileAuthoringProxy;
+ this.editorOptions = editorOptions;
+ this.languageHostIndentation = languageHostIndentation;
+ this.snapshot = this.snapshotSpan.snapshot;
+ this.DesiredIndentation = null;
+ }
+ SmartIndentTask.prototype.Run = function () {
+ var _this = this;
+ var tree = TypeScript.timeFunction(this.logger, "SmartIndentTask: new ParseTree()", function () {
+ return new Formatting.ParseTree(_this.fileAuthoringProxy, _this.snapshotSpan.span, null, true);
+ });
+ if(tree.Root == null) {
+ return;
+ }
+ Formatting.IndentationEdgeFinder.FillIndentationLevels(tree.Root);
+ Formatting.ParseTree.DumpTree(this.logger, tree.Root);
+ this.FindIndentation(tree);
+ };
+ SmartIndentTask.prototype.FindIndentation = function (tree) {
+ var caretSpan = this.snapshotSpan.span;
+ var context = Formatting.ParseTree.FindCommonParentNode(caretSpan, caretSpan, tree.Root);
+ if(context && context.AuthorNode.Details.nodeType == TypeScript.NodeType.QString) {
+ var nodeSpan = Formatting.Span.FromBounds(context.AuthorNode.Details.StartOffset, context.AuthorNode.Details.EndOffset);
+ if(nodeSpan.Contains(caretSpan)) {
+ this.DesiredIndentation = "";
+ return;
+ }
+ }
+ while(context != null && context.AuthorNode.Details.StartOffset == caretSpan.start() && !(context.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock && context.AuthorNode.Details.Flags != Formatting.AuthorParseNodeFlags.apnfSyntheticNode)) {
+ context = context.Parent;
+ }
+ if(context == null) {
+ return;
+ }
+ var firstToken = Formatting.FirstOrDefault(this.tokens, function (item) {
+ return true;
+ });
+ if(firstToken == null) {
+ firstToken = new Formatting.TokenSpan(Formatting.AuthorTokenKind.atkSColon, TypeScript.TokenID.Semicolon, this.snapshotSpan);
+ } else if(firstToken.Token != Formatting.AuthorTokenKind.atkElse && firstToken.Token != Formatting.AuthorTokenKind.atkWhile && firstToken.Token != Formatting.AuthorTokenKind.atkLCurly && firstToken.Token != Formatting.AuthorTokenKind.atkRCurly) {
+ firstToken = new Formatting.TokenSpan(Formatting.AuthorTokenKind.atkSColon, TypeScript.TokenID.Semicolon, this.snapshotSpan);
+ }
+ if(this.CanDoSmartIndent(context, {
+ token: firstToken
+ })) {
+ var indenter = new Formatting.Indenter(this.logger, tree, this.snapshot, this.languageHostIndentation, this.editorOptions, firstToken, true);
+ var edit = Formatting.FirstOrDefault(indenter.GetIndentationEdits(firstToken, null, context, true), function (item) {
+ return true;
+ });
+ if(edit != null) {
+ this.DesiredIndentation = edit.ReplaceWith;
+ }
+ }
+ };
+ SmartIndentTask.prototype.CanDoSmartIndent = function (context, firstToken) {
+ var node = context;
+ while(node != null && node.ChildrenIndentationDelta == null) {
+ node = node.Parent;
+ }
+ if(node == null) {
+ return false;
+ }
+ if(Formatting.Rules.IsTypeScriptDeclWithBlockContextNode(node)) {
+ return this.CanDoSmartIndentInStatementWithBlock(node, firstToken);
+ }
+ if(node.AuthorNode.Details.ast != null) {
+ switch(node.AuthorNode.Details.ast.nodeType) {
+ case TypeScript.NodeType.ImportDeclaration:
+ return this.CanDoSmartIndentInStatement(node);
+ }
+ }
+ switch(node.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkAsg:
+ case Formatting.AuthorParseNodeKind.apnkAsgAdd:
+ case Formatting.AuthorParseNodeKind.apnkAsgSub:
+ case Formatting.AuthorParseNodeKind.apnkAsgMul:
+ case Formatting.AuthorParseNodeKind.apnkAsgDiv:
+ case Formatting.AuthorParseNodeKind.apnkAsgMod:
+ case Formatting.AuthorParseNodeKind.apnkAsgAnd:
+ case Formatting.AuthorParseNodeKind.apnkAsgXor:
+ case Formatting.AuthorParseNodeKind.apnkAsgOr:
+ case Formatting.AuthorParseNodeKind.apnkAsgLsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRs2:
+ case Formatting.AuthorParseNodeKind.apnkVarDecl:
+ case Formatting.AuthorParseNodeKind.apnkVarDeclList:
+ case Formatting.AuthorParseNodeKind.apnkCall:
+ case Formatting.AuthorParseNodeKind.apnkArray:
+ case Formatting.AuthorParseNodeKind.apnkMember:
+ return this.CanDoSmartIndentInStatement(node);
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ return this.CanDoSmartIndentInFor(node);
+ case Formatting.AuthorParseNodeKind.apnkFncDecl:
+ return this.CanDoSmartIndentInFunction(node, firstToken);
+ case Formatting.AuthorParseNodeKind.apnkTry:
+ case Formatting.AuthorParseNodeKind.apnkFinally:
+ return this.CanDoSmartIndentInStatementWithBlock(node, firstToken);
+ case Formatting.AuthorParseNodeKind.apnkCatch:
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ return this.CanDoSmartIndentInStatementWithParenAndBlock(node, firstToken);
+ default:
+ return true;
+ }
+ };
+ SmartIndentTask.prototype.CanDoSmartIndentInStatement = function (node) {
+ var contextLine = this.snapshot.GetLineNumberFromPosition(node.AuthorNode.Details.StartOffset);
+ var newLine = this.snapshot.GetLineNumberFromPosition(this.snapshotSpan.startPosition());
+ return SmartIndentTask.IsEmptyRegion(this.snapshot, contextLine + 1, newLine - 1);
+ };
+ SmartIndentTask.prototype.CanDoSmartIndentInFunction = function (node, firstToken) {
+ var astCursor = this.fileAuthoringProxy.GetASTCursor();
+ {
+ astCursor.SeekToOffset(node.AuthorNode.Details.StartOffset, false);
+ var rightParenPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpRParenMin);
+ if(rightParenPos == 0 || this.snapshotSpan.startPosition() <= rightParenPos) {
+ return this.CanDoSmartIndentInStatement(node);
+ }
+ var leftCurlyPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpLCurlyMin);
+ if(leftCurlyPos == 0 || this.snapshotSpan.startPosition() <= leftCurlyPos) {
+ firstToken = {
+ token: new Formatting.TokenSpan(Formatting.AuthorTokenKind.atkLCurly, TypeScript.TokenID.OpenBrace, this.snapshotSpan)
+ };
+ }
+ return true;
+ }
+ };
+ SmartIndentTask.prototype.CanDoSmartIndentInStatementWithBlock = function (node, firstToken) {
+ var astCursor = this.fileAuthoringProxy.GetASTCursor();
+ {
+ astCursor.SeekToOffset(node.AuthorNode.Details.StartOffset, false);
+ var leftCurlyPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpLCurlyMin);
+ if(leftCurlyPos == 0 || this.snapshotSpan.startPosition() <= leftCurlyPos) {
+ firstToken = {
+ token: new Formatting.TokenSpan(Formatting.AuthorTokenKind.atkLCurly, TypeScript.TokenID.OpenBrace, this.snapshotSpan)
+ };
+ }
+ return true;
+ }
+ };
+ SmartIndentTask.prototype.CanDoSmartIndentInStatementWithParenAndBlock = function (node, firstToken) {
+ var astCursor = this.fileAuthoringProxy.GetASTCursor();
+ {
+ astCursor.SeekToOffset(node.AuthorNode.Details.StartOffset, false);
+ var rightParenPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpRParenMin);
+ var leftCurlyPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpLCurlyMin);
+ if(rightParenPos > 0 && this.snapshotSpan.startPosition() > rightParenPos && (leftCurlyPos == 0 || this.snapshotSpan.startPosition() <= leftCurlyPos)) {
+ firstToken = {
+ token: new Formatting.TokenSpan(Formatting.AuthorTokenKind.atkLCurly, TypeScript.TokenID.OpenBrace, this.snapshotSpan)
+ };
+ }
+ return true;
+ }
+ };
+ SmartIndentTask.prototype.CanDoSmartIndentInFor = function (node) {
+ var astCursor = this.fileAuthoringProxy.GetASTCursor();
+ {
+ astCursor.SeekToOffset(node.AuthorNode.Details.StartOffset, false);
+ var rightParenPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpRParenMin);
+ if(rightParenPos == 0 || this.snapshotSpan.startPosition() <= rightParenPos) {
+ return this.CanDoSmartIndentInStatement(node);
+ }
+ return true;
+ }
+ };
+ SmartIndentTask.IsEmptyRegion = function IsEmptyRegion(snapshot, startLine, endLine) {
+ var empty = true;
+ var lineNum = startLine;
+ while(lineNum <= endLine) {
+ var line = snapshot.GetLineFromLineNumber(lineNum);
+ var lineText = line.getText();
+ if(!SmartIndentTask.IsEmptyString(lineText)) {
+ empty = false;
+ break;
+ }
+ lineNum++;
+ }
+ return empty;
+ };
+ SmartIndentTask.IsEmptyString = function IsEmptyString(lineText) {
+ for(var i = 0, len = lineText.length; i < len; i++) {
+ if(!Formatting.EditorUtilities.IsWhitespace(lineText.charCodeAt(i))) {
+ return false;
+ }
+ }
+ return true;
+ };
+ return SmartIndentTask;
+ })();
+ Formatting.SmartIndentTask = SmartIndentTask;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var StatementFinderTask = (function () {
+ function StatementFinderTask(logger, semicolonPoint, fileAuthoringProxy) {
+ this.logger = logger;
+ this.semicolonPoint = semicolonPoint;
+ this.fileAuthoringProxy = fileAuthoringProxy;
+ this.BlockSpan = null;
+ }
+ StatementFinderTask.prototype.Run = function () {
+ var parseCursor = this.fileAuthoringProxy.GetASTCursor();
+ {
+ var startPos = -1;
+ var node = parseCursor.SeekToOffset(this.semicolonPoint.position, true);
+ while(node && node.Kind !== Formatting.AuthorParseNodeKind.apnkEmpty && node.nodeType !== TypeScript.NodeType.List) {
+ if((node.EndOffset - 1) === this.semicolonPoint.position) {
+ startPos = node.StartOffset;
+ }
+ node = parseCursor.MoveUp();
+ }
+ if(startPos !== -1) {
+ this.BlockSpan = new Formatting.Span(startPos, this.semicolonPoint.position - startPos + 1);
+ }
+ }
+ };
+ return StatementFinderTask;
+ })();
+ Formatting.StatementFinderTask = StatementFinderTask;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var TextEditInfo = (function () {
+ function TextEditInfo(position, length, replaceWith) {
+ this.position = position;
+ this.length = length;
+ this.replaceWith = replaceWith;
+ this.Position = this.position;
+ this.Length = length;
+ this.ReplaceWith = this.replaceWith;
+ }
+ return TextEditInfo;
+ })();
+ Formatting.TextEditInfo = TextEditInfo;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ (function (Shared) {
+ var TokenRangeAccess = (function () {
+ function TokenRangeAccess(from, to, except) {
+ this.tokens = new Formatting.List_AuthorTokenKind();
+ for(var token = from; token <= to; token++) {
+ if(except.indexOf(token) < 0) {
+ this.tokens.add(token);
+ }
+ }
+ }
+ TokenRangeAccess.prototype.GetTokens = function () {
+ return this.tokens;
+ };
+ TokenRangeAccess.prototype.Contains = function (token) {
+ return this.tokens.contains(token);
+ };
+ TokenRangeAccess.prototype.toString = function () {
+ return "[tokenRangeStart=" + (Formatting.AuthorTokenKind)._map[this.tokens.get(0)] + "," + "tokenRangeEnd=" + (Formatting.AuthorTokenKind)._map[this.tokens.get(this.tokens.count() - 1)] + "]";
+ };
+ return TokenRangeAccess;
+ })();
+ Shared.TokenRangeAccess = TokenRangeAccess;
+ var TokenValuesAccess = (function () {
+ function TokenValuesAccess(tks) {
+ this.tokens = new Formatting.List_AuthorTokenKind();
+ this.tokens.addAll(tks);
+ }
+ TokenValuesAccess.prototype.GetTokens = function () {
+ return this.tokens;
+ };
+ TokenValuesAccess.prototype.Contains = function (token) {
+ return this.GetTokens().contains(token);
+ };
+ return TokenValuesAccess;
+ })();
+ Shared.TokenValuesAccess = TokenValuesAccess;
+ var TokenSingleValueAccess = (function () {
+ function TokenSingleValueAccess(token) {
+ this.token = token;
+ }
+ TokenSingleValueAccess.prototype.GetTokens = function () {
+ var result = new Formatting.List_AuthorTokenKind();
+ result.add(this.token);
+ return result;
+ };
+ TokenSingleValueAccess.prototype.Contains = function (tokenValue) {
+ return tokenValue == this.token;
+ };
+ TokenSingleValueAccess.prototype.toString = function () {
+ return "[singleTokenKind=" + (Formatting.AuthorTokenKind)._map[this.token] + "]";
+ };
+ return TokenSingleValueAccess;
+ })();
+ Shared.TokenSingleValueAccess = TokenSingleValueAccess;
+ var TokenAllAccess = (function () {
+ function TokenAllAccess() { }
+ TokenAllAccess.prototype.GetTokens = function () {
+ var result = new Formatting.List_AuthorTokenKind();
+ for(var token = Formatting.AuthorTokenKind.atkEnd; token < Formatting.AuthorTokenKind.Length; token++) {
+ result.add(token);
+ }
+ return result;
+ };
+ TokenAllAccess.prototype.Contains = function (tokenValue) {
+ return true;
+ };
+ TokenAllAccess.prototype.toString = function () {
+ return "[allTokens]";
+ };
+ return TokenAllAccess;
+ })();
+ Shared.TokenAllAccess = TokenAllAccess;
+ var TokenRange = (function () {
+ function TokenRange(tokenAccess) {
+ this.tokenAccess = tokenAccess;
+ }
+ TokenRange.FromToken = function FromToken(token) {
+ return new TokenRange(new TokenSingleValueAccess(token));
+ };
+ TokenRange.FromTokens = function FromTokens(tokens) {
+ return new TokenRange(new TokenValuesAccess(tokens));
+ };
+ TokenRange.FromRange = function FromRange(f, to, except) {
+ if (typeof except === "undefined") { except = []; }
+ return new TokenRange(new TokenRangeAccess(f, to, except));
+ };
+ TokenRange.AllTokens = function AllTokens() {
+ return new TokenRange(new TokenAllAccess());
+ };
+ TokenRange.prototype.GetTokens = function () {
+ return this.tokenAccess.GetTokens();
+ };
+ TokenRange.prototype.Contains = function (token) {
+ return this.tokenAccess.Contains(token);
+ };
+ TokenRange.prototype.toString = function () {
+ return this.tokenAccess.toString();
+ };
+ TokenRange.Any = TokenRange.AllTokens();
+ TokenRange.Keywords = TokenRange.FromRange(Formatting.AuthorTokenKind.atkBreak, Formatting.AuthorTokenKind.atkWith);
+ TokenRange.Operators = TokenRange.FromRange(Formatting.AuthorTokenKind.atkSColon, Formatting.AuthorTokenKind.atkScope);
+ TokenRange.BinaryOperators = TokenRange.FromRange(Formatting.AuthorTokenKind.atkArrow, Formatting.AuthorTokenKind.atkPct);
+ TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIn,
+ Formatting.AuthorTokenKind.atkInstanceof
+ ]);
+ TokenRange.ReservedKeywords = TokenRange.FromRange(Formatting.AuthorTokenKind.atkImplements, Formatting.AuthorTokenKind.atkYield);
+ TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkAdd,
+ Formatting.AuthorTokenKind.atkSub,
+ Formatting.AuthorTokenKind.atkTilde,
+ Formatting.AuthorTokenKind.atkBang
+ ]);
+ TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkNumber,
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkLParen,
+ Formatting.AuthorTokenKind.atkLBrack,
+ Formatting.AuthorTokenKind.atkLCurly,
+ Formatting.AuthorTokenKind.atkThis,
+ Formatting.AuthorTokenKind.atkNew
+ ]);
+ TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkLParen,
+ Formatting.AuthorTokenKind.atkThis,
+ Formatting.AuthorTokenKind.atkNew
+ ]);
+ TokenRange.UnaryPostincrementExpressions = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkRBrack,
+ Formatting.AuthorTokenKind.atkNew
+ ]);
+ TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkLParen,
+ Formatting.AuthorTokenKind.atkThis,
+ Formatting.AuthorTokenKind.atkNew
+ ]);
+ TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkRBrack,
+ Formatting.AuthorTokenKind.atkNew
+ ]);
+ return TokenRange;
+ })();
+ Shared.TokenRange = TokenRange;
+ })(Formatting.Shared || (Formatting.Shared = {}));
+ var Shared = Formatting.Shared;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var TokenSpan = (function () {
+ function TokenSpan(Token, tokenID, Span) {
+ this.Token = Token;
+ this.tokenID = tokenID;
+ this.Span = Span;
+ this._lineNumber = null;
+ }
+ TokenSpan.prototype.lineNumber = function () {
+ if(this._lineNumber === null) {
+ this._lineNumber = this.Span.snapshot.GetLineNumberFromPosition(this.Span.startPosition());
+ }
+ return this._lineNumber;
+ };
+ TokenSpan.prototype.toString = function () {
+ var result = "[tokenKind=" + (Formatting.AuthorTokenKind)._map[this.Token] + ", " + "tokenID=" + (TypeScript.TokenID)._map[this.tokenID] + ", " + "lineNumber=" + this._lineNumber + ", " + "span=" + this.Span + "]";
+ return result;
+ };
+ return TokenSpan;
+ })();
+ Formatting.TokenSpan = TokenSpan;
+})(Formatting || (Formatting = {}));
+var debugObjectHost = (this);
+var Services;
+(function (Services) {
+ var CoreServices = (function () {
+ function CoreServices(host) {
+ this.host = host;
+ }
+ CoreServices.prototype.getPreProcessedFileInfo = function (scritpId, sourceText) {
+ var settings = new TypeScript.CompilationSettings();
+ settings.codeGenTarget = TypeScript.CodeGenTarget.ES5;
+ var result = TypeScript.preProcessFile(sourceText, settings);
+ return result;
+ };
+ CoreServices.prototype.getDefaultCompilationSettings = function () {
+ var settings = new TypeScript.CompilationSettings();
+ settings.codeGenTarget = TypeScript.CodeGenTarget.ES5;
+ return settings;
+ };
+ CoreServices.prototype.dumpMemory = function () {
+ if(!debugObjectHost || !debugObjectHost.Debug || !debugObjectHost.Debug.dumpHeap) {
+ throw new Error("This version of the Javascript runtime doesn't support the 'Debug.dumpHeap()' function.");
+ }
+ var objects = debugObjectHost.Debug.dumpHeap(2);
+ var totalSize = 0;
+ for(var i = 0; i < objects.length; i++) {
+ totalSize += objects[i].size;
+ }
+ return "There are " + objects.length + " object(s) accessible from 'global', for a total of " + totalSize + " byte(s).";
+ };
+ CoreServices.prototype.getMemoryInfo = function () {
+ if(!debugObjectHost || !debugObjectHost.Debug || !debugObjectHost.Debug.getMemoryInfo) {
+ throw new Error("This version of the Javascript runtime doesn't support the 'Debug.getMemoryInfo()' function.");
+ }
+ return debugObjectHost.Debug.getMemoryInfo();
+ };
+ CoreServices.prototype.collectGarbage = function () {
+ if(!debugObjectHost || !debugObjectHost.CollectGarbage) {
+ throw new Error("This version of the Javascript runtime doesn't support the 'CollectGarbage()' function.");
+ }
+ debugObjectHost.CollectGarbage();
+ };
+ return CoreServices;
+ })();
+ Services.CoreServices = CoreServices;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var ScriptMap = (function () {
+ function ScriptMap() {
+ this.map = new TypeScript.StringHashTable();
+ }
+ ScriptMap.prototype.setEntry = function (id, isResident, version) {
+ var entry = this.map.lookup(id);
+ if(entry == null) {
+ entry = new ScriptMapEntry(isResident, version);
+ this.map.add(id, entry);
+ } else {
+ entry.isResident = isResident;
+ entry.version = version;
+ }
+ };
+ ScriptMap.prototype.getEntry = function (id) {
+ return this.map.lookup(id);
+ };
+ return ScriptMap;
+ })();
+ Services.ScriptMap = ScriptMap;
+ var ScriptMapEntry = (function () {
+ function ScriptMapEntry(isResident, version) {
+ this.isResident = isResident;
+ this.version = version;
+ }
+ return ScriptMapEntry;
+ })();
+ Services.ScriptMapEntry = ScriptMapEntry;
+ var HostCacheEntry = (function () {
+ function HostCacheEntry(host, hostUnitIndex, id, version, isResident) {
+ this.host = host;
+ this.hostUnitIndex = hostUnitIndex;
+ this.id = id;
+ this.version = version;
+ this.isResident = isResident;
+ this._cachedSourceText = null;
+ this._sourceText = null;
+ }
+ HostCacheEntry.prototype.getSourceText = function (cached) {
+ if(cached) {
+ if(this._cachedSourceText === null) {
+ this._cachedSourceText = new Services.CachedSourceTextAdapter(this.host, this.hostUnitIndex);
+ }
+ return this._cachedSourceText;
+ } else {
+ if(this._sourceText === null) {
+ this._sourceText = new Services.SourceTextAdapter(this.host, this.hostUnitIndex);
+ }
+ return this._sourceText;
+ }
+ };
+ return HostCacheEntry;
+ })();
+ Services.HostCacheEntry = HostCacheEntry;
+ var HostCache = (function () {
+ function HostCache(host) {
+ this.host = host;
+ this.map = new TypeScript.StringHashTable();
+ this.array = [];
+ this.init();
+ }
+ HostCache.prototype.init = function () {
+ for(var i = 0, len = this.host.getScriptCount(); i < len; i++) {
+ var scriptId = this.host.getScriptId(i);
+ this.map.add(scriptId, i);
+ this.array[i] = new HostCacheEntry(this.host, i, scriptId, this.host.getScriptVersion(i), this.host.getScriptIsResident(i));
+ }
+ };
+ HostCache.prototype.count = function () {
+ return this.map.count();
+ };
+ HostCache.prototype.getUnitIndex = function (scriptId) {
+ var result = this.map.lookup(scriptId);
+ if(result == null) {
+ return -1;
+ }
+ return result;
+ };
+ HostCache.prototype.getVersion = function (scriptIndex) {
+ return this.array[scriptIndex].version;
+ };
+ HostCache.prototype.getIsResident = function (scriptIndex) {
+ return this.array[scriptIndex].isResident;
+ };
+ HostCache.prototype.getScriptId = function (scriptIndex) {
+ return this.array[scriptIndex].id;
+ };
+ HostCache.prototype.getSourceText = function (scriptIndex, cached) {
+ if (typeof cached === "undefined") { cached = false; }
+ return this.array[scriptIndex].getSourceText(cached);
+ };
+ return HostCache;
+ })();
+ Services.HostCache = HostCache;
+ var CompilerCache = (function () {
+ function CompilerCache(compiler) {
+ this.compiler = compiler;
+ this.map = new TypeScript.StringHashTable();
+ this.init();
+ }
+ CompilerCache.prototype.init = function () {
+ for(var i = 0, len = this.compiler.units.length; i < len; i++) {
+ this.map.add(this.compiler.units[i].filename, i);
+ }
+ };
+ CompilerCache.prototype.getUnitIndex = function (scriptId) {
+ var result = this.map.lookup(scriptId);
+ if(result == null) {
+ return -1;
+ }
+ return result;
+ };
+ return CompilerCache;
+ })();
+ Services.CompilerCache = CompilerCache;
+ var UnitErrors = (function () {
+ function UnitErrors() {
+ this.parseErrors = [];
+ this.typeCheckErrors = [];
+ }
+ return UnitErrors;
+ })();
+ Services.UnitErrors = UnitErrors;
+ var CompilerErrorCollector = (function () {
+ function CompilerErrorCollector(logger) {
+ this.logger = logger;
+ this.parseMode = false;
+ this.fileMap = [];
+ }
+ CompilerErrorCollector.prototype.startParsing = function (unitIndex) {
+ this.parseMode = true;
+ var errors = this.fileMap[unitIndex];
+ if(errors !== undefined) {
+ errors.parseErrors.length = 0;
+ }
+ };
+ CompilerErrorCollector.prototype.startTypeChecking = function () {
+ this.parseMode = false;
+ for(var i = 0; i < this.fileMap.length; i++) {
+ var errors = this.fileMap[i];
+ if(errors !== undefined) {
+ errors.typeCheckErrors.length = 0;
+ }
+ }
+ };
+ CompilerErrorCollector.prototype.reportError = function (pos, len, message, unitIndex) {
+ var entry = new TypeScript.ErrorEntry(unitIndex, pos, pos + len, message);
+ var unitErrors = this.fileMap[unitIndex];
+ if(unitErrors == undefined) {
+ unitErrors = new UnitErrors();
+ this.fileMap[unitIndex] = unitErrors;
+ }
+ if(this.parseMode) {
+ unitErrors.parseErrors.push(entry);
+ } else {
+ unitErrors.typeCheckErrors.push(entry);
+ }
+ };
+ return CompilerErrorCollector;
+ })();
+ Services.CompilerErrorCollector = CompilerErrorCollector;
+ var TextWriter = (function () {
+ function TextWriter(name, useUTF8encoding) {
+ this.name = name;
+ this.useUTF8encoding = useUTF8encoding;
+ this.text = "";
+ }
+ TextWriter.prototype.Write = function (s) {
+ this.text += s;
+ };
+ TextWriter.prototype.WriteLine = function (s) {
+ this.text += s + '\n';
+ };
+ TextWriter.prototype.Close = function () {
+ };
+ return TextWriter;
+ })();
+ var CompilerState = (function () {
+ function CompilerState(host) {
+ this.host = host;
+ this.logger = this.host;
+ this.compiler = null;
+ this.errorCollector = null;
+ this.unitIndexMap = [];
+ this.scriptMap = null;
+ this.hostCache = null;
+ this.compilerCache = null;
+ this.symbolTree = null;
+ this.compilationSettings = null;
+ }
+ CompilerState.prototype.getCompilationSettings = function () {
+ return this.compilationSettings;
+ };
+ CompilerState.prototype.setUnitMapping = function (unitIndex, hostUnitIndex) {
+ this.scriptMap.setEntry(this.hostCache.getScriptId(hostUnitIndex), this.hostCache.getIsResident(hostUnitIndex), this.hostCache.getVersion(hostUnitIndex));
+ this.setUnitIndexMapping(unitIndex, hostUnitIndex);
+ };
+ CompilerState.prototype.setUnitIndexMapping = function (unitIndex, hostUnitIndex) {
+ this.unitIndexMap[unitIndex] = hostUnitIndex;
+ };
+ CompilerState.prototype.onTypeCheckStarting = function () {
+ this.errorCollector.startTypeChecking();
+ this.symbolTree = new Services.SymbolTree(this);
+ };
+ CompilerState.prototype.getSymbolTree = function () {
+ return this.symbolTree;
+ };
+ CompilerState.prototype.mapToHostUnitIndex = function (unitIndex) {
+ return this.unitIndexMap[unitIndex];
+ };
+ CompilerState.prototype.anyType = function () {
+ return this.compiler.typeFlow.anyType;
+ };
+ CompilerState.prototype.getScriptCount = function () {
+ return this.compiler.scripts.members.length;
+ };
+ CompilerState.prototype.getScript = function (index) {
+ return this.compiler.scripts.members[index];
+ };
+ CompilerState.prototype.getScripts = function () {
+ return this.compiler.scripts.members;
+ };
+ CompilerState.prototype.getUnitIndex = function (fileName) {
+ return this.compilerCache.getUnitIndex(fileName);
+ };
+ CompilerState.prototype.getScriptVersion = function (fileName) {
+ return this.hostCache.getVersion(this.hostCache.getUnitIndex(fileName));
+ };
+ CompilerState.prototype.addCompilerUnit = function (compiler, hostUnitIndex) {
+ var newUnitIndex = compiler.units.length;
+ this.errorCollector.startParsing(newUnitIndex);
+ this.setUnitMapping(newUnitIndex, hostUnitIndex);
+ var newScript = compiler.addSourceUnit(this.hostCache.getSourceText(hostUnitIndex), this.hostCache.getScriptId(hostUnitIndex), this.hostCache.getIsResident(hostUnitIndex));
+ };
+ CompilerState.prototype.updateCompilerUnit = function (compiler, hostUnitIndex, unitIndex) {
+ var scriptId = this.hostCache.getScriptId(hostUnitIndex);
+ this.setUnitIndexMapping(unitIndex, hostUnitIndex);
+ var previousEntry = this.scriptMap.getEntry(scriptId);
+ var isResident = this.hostCache.getIsResident(hostUnitIndex);
+ if(isResident) {
+ return TypeScript.UpdateUnitResult.noEdits(unitIndex);
+ }
+ var version = this.hostCache.getVersion(hostUnitIndex);
+ if(previousEntry.version === version) {
+ return TypeScript.UpdateUnitResult.noEdits(unitIndex);
+ }
+ var result = this.attemptIncrementalUpdateUnit(scriptId);
+ if(result != null) {
+ return result;
+ }
+ var sourceText = this.hostCache.getSourceText(hostUnitIndex);
+ this.setUnitMapping(unitIndex, hostUnitIndex);
+ return compiler.partialUpdateUnit(sourceText, scriptId, true);
+ };
+ CompilerState.prototype.attemptIncrementalUpdateUnit = function (scriptId) {
+ var previousScript = this.getScriptAST(scriptId);
+ var newSourceText = this.getSourceText(previousScript, false);
+ var editRange = this.getScriptEditRange(previousScript);
+ var result = new TypeScript.IncrementalParser(this.logger).attemptIncrementalUpdateUnit(previousScript, scriptId, newSourceText, editRange);
+ if(result == null) {
+ return null;
+ }
+ if(result.kind === TypeScript.UpdateUnitKind.EditsInsideSingleScope) {
+ if(result.scope1.nodeType != TypeScript.NodeType.FuncDecl) {
+ this.logger.log(" Bailing out because containing scope is not a function");
+ return null;
+ }
+ }
+ if(true) {
+ this.logger.log(" Bailing out because incremental typecheck is not implemented yet");
+ return null;
+ } else {
+ return result;
+ }
+ };
+ CompilerState.prototype.getHostCompilationSettings = function () {
+ var settings = this.host.getCompilationSettings();
+ if(settings !== null) {
+ return settings;
+ }
+ settings = new TypeScript.CompilationSettings();
+ settings.codeGenTarget = TypeScript.CodeGenTarget.ES5;
+ return settings;
+ };
+ CompilerState.prototype.createCompiler = function () {
+ var _this = this;
+ var outerr = {
+ Write: function (s) {
+ },
+ WriteLine: function (s) {
+ },
+ Close: function () {
+ }
+ };
+ this.logger.log("Initializing compiler");
+ this.compilationSettings = new TypeScript.CompilationSettings();
+ Services.copyDataObject(this.compilationSettings, this.getHostCompilationSettings());
+ this.compiler = new TypeScript.TypeScriptCompiler(outerr, this.logger, this.compilationSettings);
+ this.scriptMap = new ScriptMap();
+ this.unitIndexMap = [];
+ this.errorCollector = new CompilerErrorCollector(this.logger);
+ this.compiler.setErrorCallback(function (a, b, c, d) {
+ _this.errorCollector.reportError(a, b, c, d);
+ });
+ this.compiler.parser.errorRecovery = true;
+ for(var i = 0, length = this.host.getScriptCount(); i < length; i++) {
+ this.addCompilerUnit(this.compiler, i);
+ }
+ this.compilerCache = new CompilerCache(this.compiler);
+ this.onTypeCheckStarting();
+ this.compiler.typeCheck();
+ };
+ CompilerState.prototype.minimalRefresh = function () {
+ this.hostCache = new HostCache(this.host);
+ };
+ CompilerState.prototype.refresh = function (throwOnError) {
+ if (typeof throwOnError === "undefined") { throwOnError = true; }
+ try {
+ this.hostCache = new HostCache(this.host);
+ if(!this.fullRefresh()) {
+ this.partialRefresh();
+ }
+ if(this.logger.information()) {
+ for(var i = 0; i < this.compiler.units.length; i++) {
+ this.logger.log("compiler unit[" + i + "].filename='" + this.compiler.units[i].filename + "'");
+ }
+ for(var i = 0; i < this.hostCache.count(); i++) {
+ this.logger.log("host script[" + i + "].filename='" + this.hostCache.getScriptId(i) + "', version=" + this.hostCache.getVersion(i));
+ }
+ for(var i = 0; i < this.unitIndexMap.length; i++) {
+ this.logger.log("unitIndexMap[" + i + "] = " + this.unitIndexMap[i]);
+ }
+ }
+ } catch (err) {
+ var lastUnitIndex = 0;
+ if(this.compiler != null) {
+ lastUnitIndex = this.compiler.units.length - 1;
+ }
+ this.compiler = null;
+ this.logger.log("WARNING: PERF: Internal error during \"Refresh\":");
+ Services.logInternalError(this.logger, err);
+ this.logger.log("WARNING: PERF: Compiler state is lost and will be re-initiliazed during next call.");
+ this.errorCollector.reportError(0, 1, "Internal error: " + err.message, lastUnitIndex);
+ this.errorCollector.reportError(0, 1, "Internal error: IntelliSense features are disabled. Try making edits to source files to restore a valid compilation state.", lastUnitIndex);
+ if(throwOnError) {
+ throw err;
+ }
+ }
+ };
+ CompilerState.prototype.fullRefresh = function () {
+ if(this.compiler == null) {
+ this.logger.log("Creating new compiler instance because there is no currently active instance");
+ this.createCompiler();
+ return true;
+ }
+ if(!Services.compareDataObjects(this.compilationSettings, this.getHostCompilationSettings())) {
+ this.logger.log("Creating new compiler instance because compilation settings have changed.");
+ this.createCompiler();
+ return true;
+ }
+ for(var unitIndex = 0, len = this.compiler.units.length; unitIndex < len; unitIndex++) {
+ var fileName = this.compiler.units[unitIndex].filename;
+ var hostUnitIndex = this.hostCache.getUnitIndex(fileName);
+ if(hostUnitIndex < 0) {
+ this.logger.log("Creating new compiler instance because of unit is not part of program anymore: " + unitIndex + "-" + fileName);
+ this.createCompiler();
+ return true;
+ }
+ }
+ for(var unitIndex = 0, len = this.compiler.units.length; unitIndex < len; unitIndex++) {
+ var fileName = this.compiler.units[unitIndex].filename;
+ var isResident = (this.compiler.scripts.members[unitIndex]).isResident;
+ var hostUnitIndex = this.hostCache.getUnitIndex(fileName);
+ if(this.hostCache.getIsResident(hostUnitIndex) != isResident) {
+ this.logger.log("Creating new compiler instance because of unit 'isResident' status has changed: " + unitIndex + "-" + fileName);
+ this.createCompiler();
+ return true;
+ }
+ }
+ return false;
+ };
+ CompilerState.prototype.partialRefresh = function () {
+ this.logger.log("Updating files...");
+ this.compilerCache = new CompilerCache(this.compiler);
+ var updateResults = [];
+ function getSingleFunctionEdit(updateResults) {
+ var result = null;
+ for(var i = 0, len = updateResults.length; i < len; i++) {
+ var entry = updateResults[i];
+ if(entry.kind == TypeScript.UpdateUnitKind.EditsInsideSingleScope) {
+ if(result === null) {
+ result = entry;
+ } else {
+ result = null;
+ break;
+ }
+ } else if(entry.kind == TypeScript.UpdateUnitKind.Unknown) {
+ result = null;
+ break;
+ }
+ }
+ return result;
+ }
+ var fileAdded = false;
+ for(var hostUnitIndex = 0, len = this.host.getScriptCount(); hostUnitIndex < len; hostUnitIndex++) {
+ var fileName = this.hostCache.getScriptId(hostUnitIndex);
+ var unitIndex = this.compilerCache.getUnitIndex(fileName);
+ if(unitIndex >= 0) {
+ var updateResult = this.updateCompilerUnit(this.compiler, hostUnitIndex, unitIndex);
+ updateResults.push(updateResult);
+ } else {
+ this.addCompilerUnit(this.compiler, hostUnitIndex);
+ fileAdded = true;
+ }
+ }
+ var incrementalTypeCheckSuccessful = false;
+ var singleEdit = getSingleFunctionEdit(updateResults);
+ if(fileAdded === false && singleEdit !== null) {
+ this.logger.log("Attempting incremental type check because there was a single edit to the function \"" + (singleEdit.scope1).name.actualText + "\"");
+ incrementalTypeCheckSuccessful = this.attemptIncrementalTypeCheck(singleEdit);
+ }
+ if(!incrementalTypeCheckSuccessful) {
+ var anythingUpdated = false;
+ for(var i = 0, len = updateResults.length; i < len; i++) {
+ var entry = updateResults[i];
+ if(this.applyUpdateResult(entry)) {
+ anythingUpdated = true;
+ }
+ }
+ if(anythingUpdated) {
+ this.logger.log("Incremental type check not applicable, processing unit updates");
+ this.onTypeCheckStarting();
+ this.compiler.reTypeCheck();
+ } else {
+ this.logger.log("No updates to source files, no typecheck needed");
+ }
+ }
+ };
+ CompilerState.prototype.attemptIncrementalTypeCheck = function (updateResult) {
+ var success = this.compiler.attemptIncrementalTypeCheck(updateResult);
+ if(success) {
+ this.applyUpdateResult(updateResult);
+ }
+ return success;
+ };
+ CompilerState.prototype.applyUpdateResult = function (updateResult) {
+ switch(updateResult.kind) {
+ case TypeScript.UpdateUnitKind.NoEdits:
+ return false;
+ case TypeScript.UpdateUnitKind.Unknown:
+ case TypeScript.UpdateUnitKind.EditsInsideSingleScope:
+ this.errorCollector.startParsing(updateResult.unitIndex);
+ return this.compiler.applyUpdateResult(updateResult);
+ }
+ };
+ CompilerState.prototype.getScriptAST = function (fileName) {
+ var unitIndex = this.compilerCache.getUnitIndex(fileName);
+ if(unitIndex < 0) {
+ throw new Error("Interal error: No AST found for file \"" + fileName + "\".");
+ }
+ return this.compiler.scripts.members[unitIndex];
+ };
+ CompilerState.prototype.getLineMap = function (fileName) {
+ var unitIndex = this.compilerCache.getUnitIndex(fileName);
+ if(unitIndex < 0) {
+ throw new Error("Interal error: No AST found for file \"" + fileName + "\".");
+ }
+ return this.compiler.units[unitIndex].lineMap;
+ };
+ CompilerState.prototype.getScopeEntries = function (enclosingScopeContext, getPrettyTypeName) {
+ return new TypeScript.ScopeTraversal(this.compiler).getScopeEntries(enclosingScopeContext, getPrettyTypeName);
+ };
+ CompilerState.prototype.getErrorEntries = function (maxCount, filter) {
+ var entries = [];
+ var count = 0;
+ var addError = function (error) {
+ entries.push(error);
+ count++;
+ return (count < maxCount);
+ };
+ for(var unitIndex = 0, len = this.errorCollector.fileMap.length; unitIndex < len; unitIndex++) {
+ var errors = this.errorCollector.fileMap[unitIndex];
+ if(errors !== undefined) {
+ for(var i = 0; i < errors.parseErrors.length; i++) {
+ var error = errors.parseErrors[i];
+ if(filter(unitIndex, error)) {
+ if(!addError(error)) {
+ break;
+ }
+ }
+ }
+ for(var i = 0; i < errors.typeCheckErrors.length; i++) {
+ var error = errors.typeCheckErrors[i];
+ if(filter(unitIndex, error)) {
+ if(!addError(error)) {
+ break;
+ }
+ }
+ }
+ }
+ }
+ var result = [];
+ for(var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ var ne = new TypeScript.ErrorEntry(this.mapToHostUnitIndex(e.unitIndex), e.minChar, e.limChar, e.message);
+ result.push(ne);
+ }
+ return result;
+ };
+ CompilerState.prototype.cleanASTTypesForReTypeCheck = function (ast) {
+ this.compiler.cleanASTTypesForReTypeCheck(ast);
+ };
+ CompilerState.prototype.getScriptEditRange = function (script) {
+ var lastKnownVersion = this.scriptMap.getEntry(script.locationInfo.filename).version;
+ return this.getScriptEditRangeSinceVersion(script.locationInfo.filename, lastKnownVersion);
+ };
+ CompilerState.prototype.getScriptEditRangeSinceVersion = function (fileName, lastKnownVersion) {
+ var hostUnitIndex = this.hostCache.getUnitIndex(fileName);
+ var currentVersion = this.hostCache.getVersion(hostUnitIndex);
+ if(lastKnownVersion === currentVersion) {
+ return null;
+ }
+ return this.host.getScriptEditRangeSinceVersion(hostUnitIndex, lastKnownVersion);
+ };
+ CompilerState.prototype.getSourceText = function (script, cached) {
+ if (typeof cached === "undefined") { cached = false; }
+ return this.hostCache.getSourceText(this.hostCache.getUnitIndex(script.locationInfo.filename), cached);
+ };
+ CompilerState.prototype.getSourceText2 = function (fileName, cached) {
+ if (typeof cached === "undefined") { cached = false; }
+ return this.hostCache.getSourceText(this.hostCache.getUnitIndex(fileName), cached);
+ };
+ CompilerState.prototype.getScriptSyntaxAST = function (fileName) {
+ var sourceText = this.hostCache.getSourceText(this.hostCache.getUnitIndex(fileName), true);
+ var parser = new TypeScript.Parser();
+ parser.setErrorRecovery(null);
+ parser.errorCallback = function (a, b, c, d) {
+ };
+ var script = parser.parse(sourceText, fileName, 0);
+ return new Services.ScriptSyntaxAST(this.logger, script, sourceText);
+ };
+ CompilerState.prototype.getEmitOutput = function (fileName) {
+ var unitIndex = this.compilerCache.getUnitIndex(fileName);
+ if(unitIndex < 0) {
+ throw new Error("Interal error: No AST found for file \"" + fileName + "\".");
+ }
+ var result = [];
+ var errors = this.errorCollector.fileMap[unitIndex];
+ if(errors !== undefined && errors.parseErrors.length > 0) {
+ return result;
+ }
+ var emitterIOHost = {
+ createFile: function (fileName, useUTF8encoding) {
+ if (typeof useUTF8encoding === "undefined") { useUTF8encoding = false; }
+ var outputFile = new TextWriter(fileName, useUTF8encoding);
+ result.push(outputFile);
+ return outputFile;
+ },
+ directoryExists: function (fname) {
+ return true;
+ },
+ fileExists: function (fname) {
+ return false;
+ },
+ resolvePath: function (fname) {
+ return fname;
+ }
+ };
+ var script = this.compiler.scripts.members[unitIndex];
+ this.compiler.parseEmitOption(emitterIOHost);
+ this.compiler.emitUnit(script);
+ if(errors == undefined || errors.typeCheckErrors.length == 0) {
+ this.compiler.emitDeclarationsUnit(script);
+ }
+ return result;
+ };
+ return CompilerState;
+ })();
+ Services.CompilerState = CompilerState;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var ScriptSyntaxAST = (function () {
+ function ScriptSyntaxAST(logger, script, sourceText) {
+ this.logger = logger;
+ this.script = script;
+ this.sourceText = sourceText;
+ }
+ ScriptSyntaxAST.prototype.getLogger = function () {
+ return this.logger;
+ };
+ ScriptSyntaxAST.prototype.getScriptId = function () {
+ return this.script.locationInfo.filename;
+ };
+ ScriptSyntaxAST.prototype.getScript = function () {
+ return this.script;
+ };
+ ScriptSyntaxAST.prototype.getSourceText = function () {
+ return this.sourceText;
+ };
+ ScriptSyntaxAST.prototype.getTokenStream = function (minChar, limChar) {
+ if (typeof minChar === "undefined") { minChar = 0; }
+ if(minChar > 0) {
+ minChar = this.getTokenizationOffset(minChar);
+ }
+ if(!limChar) {
+ limChar = this.getSourceText().getLength();
+ }
+ var scannerSourceText = this.getSourceText();
+ if(minChar > 0 || limChar < scannerSourceText.getLength()) {
+ scannerSourceText = new Services.SourceTextRange(scannerSourceText, minChar, limChar);
+ }
+ var scanner = new TypeScript.Scanner();
+ scanner.resetComments();
+ scanner.setSourceText(scannerSourceText, TypeScript.LexMode.File);
+ scanner.setScanComments(true);
+ var tokenStream = new TokenStream(scanner, minChar);
+ return tokenStream;
+ };
+ ScriptSyntaxAST.prototype.getTokenizationOffset = function (position) {
+ return TypeScript.getTokenizationOffset(this.script, position);
+ };
+ ScriptSyntaxAST.prototype.getAstPathToPosition = function (pos, options) {
+ if (typeof options === "undefined") { options = TypeScript.GetAstPathOptions.Default; }
+ return TypeScript.getAstPathToPosition(this.script, pos, options);
+ };
+ return ScriptSyntaxAST;
+ })();
+ Services.ScriptSyntaxAST = ScriptSyntaxAST;
+ var TokenStream = (function () {
+ function TokenStream(scanner, offset) {
+ this.scanner = scanner;
+ this.offset = offset;
+ this.currentToken = null;
+ }
+ TokenStream.prototype.moveNext = function () {
+ this.currentToken = this.scanner.scan();
+ if(this.currentToken.tokenId === TypeScript.TokenID.EndOfFile) {
+ return false;
+ }
+ return true;
+ };
+ TokenStream.prototype.sourceTextOffset = function () {
+ return this.offset;
+ };
+ TokenStream.prototype.tokenId = function () {
+ return this.currentToken.tokenId;
+ };
+ TokenStream.prototype.tokenStartPos = function () {
+ return this.offset + this.scanner.startPos;
+ };
+ TokenStream.prototype.tokenEndPos = function () {
+ return this.offset + this.scanner.pos;
+ };
+ return TokenStream;
+ })();
+ Services.TokenStream = TokenStream;
+ var TokenStreamHelper = (function () {
+ function TokenStreamHelper(stream) {
+ this.stream = stream;
+ this.moveNext();
+ }
+ TokenStreamHelper.prototype.moveNext = function () {
+ do {
+ if(!this.stream.moveNext()) {
+ return false;
+ }
+ }while(this.tokenId() === TypeScript.TokenID.Comment);
+ return true;
+ };
+ TokenStreamHelper.prototype.expect = function (token) {
+ if(this.stream.tokenId() === token) {
+ this.moveNext();
+ return true;
+ }
+ return false;
+ };
+ TokenStreamHelper.prototype.skipToOffset = function (pos) {
+ while(this.tokenStartPos() < pos) {
+ if(!this.moveNext()) {
+ return false;
+ }
+ }
+ return true;
+ };
+ TokenStreamHelper.prototype.tokenId = function () {
+ return this.stream.tokenId();
+ };
+ TokenStreamHelper.prototype.tokenStartPos = function () {
+ return this.stream.tokenStartPos();
+ };
+ TokenStreamHelper.prototype.tokenEndPos = function () {
+ return this.stream.tokenEndPos();
+ };
+ return TokenStreamHelper;
+ })();
+ Services.TokenStreamHelper = TokenStreamHelper;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var BraceMatchingManager = (function () {
+ function BraceMatchingManager(scriptSyntaxAST) {
+ this.scriptSyntaxAST = scriptSyntaxAST;
+ }
+ BraceMatchingManager.prototype.getBraceMatchingAtPosition = function (position) {
+ var openBraces = "{([";
+ var openBracesTokens = [
+ TypeScript.TokenID.OpenBrace,
+ TypeScript.TokenID.OpenParen,
+ TypeScript.TokenID.OpenBracket
+ ];
+ var closeBraces = "})]";
+ var closeBracesTokens = [
+ TypeScript.TokenID.CloseBrace,
+ TypeScript.TokenID.CloseParen,
+ TypeScript.TokenID.CloseBracket
+ ];
+ var result = new Array();
+ var character = this.scriptSyntaxAST.getSourceText().getText(position, position + 1);
+ var openBraceIndex = openBraces.indexOf(character);
+ if(openBraceIndex >= 0) {
+ var closeBracePos = this.getMatchingBraceForward(position, openBracesTokens[openBraceIndex], closeBracesTokens[openBraceIndex]);
+ if(closeBracePos >= 0) {
+ var range1 = new Services.TextRange(position, position + 1);
+ var range2 = new Services.TextRange(closeBracePos, closeBracePos + 1);
+ result.push(range1, range2);
+ }
+ }
+ character = this.scriptSyntaxAST.getSourceText().getText(position - 1, position);
+ var closeBraceIndex = closeBraces.indexOf(character);
+ if(closeBraceIndex >= 0) {
+ var openBracePos = this.getMatchingBraceBackward(position - 1, closeBracesTokens[closeBraceIndex], openBracesTokens[closeBraceIndex]);
+ if(openBracePos >= 0) {
+ var range1 = new Services.TextRange(position - 1, position);
+ var range2 = new Services.TextRange(openBracePos, openBracePos + 1);
+ result.push(range1, range2);
+ }
+ }
+ return result;
+ };
+ BraceMatchingManager.prototype.getMatchingBraceForward = function (position, openToken, closeToken) {
+ var tokenStream = this.scriptSyntaxAST.getTokenStream();
+ var balanceCount = 0;
+ var foundOpenToken = false;
+ while(tokenStream.moveNext()) {
+ if(tokenStream.tokenStartPos() === position) {
+ if(tokenStream.tokenId() === openToken) {
+ foundOpenToken = true;
+ } else {
+ break;
+ }
+ }
+ if(foundOpenToken) {
+ if(tokenStream.tokenId() === openToken) {
+ balanceCount++;
+ } else if(tokenStream.tokenId() === closeToken) {
+ balanceCount--;
+ if(balanceCount === 0) {
+ return tokenStream.tokenStartPos();
+ }
+ }
+ }
+ }
+ return -1;
+ };
+ BraceMatchingManager.prototype.getMatchingBraceBackward = function (position, closeToken, openToken) {
+ var tokenStream = this.scriptSyntaxAST.getTokenStream();
+ var openTokenPositions = [];
+ var foundOpenToken = false;
+ while(tokenStream.moveNext()) {
+ if(tokenStream.tokenStartPos() > position) {
+ break;
+ }
+ if(tokenStream.tokenStartPos() === position && tokenStream.tokenId() === closeToken) {
+ if(openTokenPositions.length > 0) {
+ return openTokenPositions[openTokenPositions.length - 1];
+ }
+ break;
+ }
+ if(tokenStream.tokenId() === openToken) {
+ openTokenPositions.push(tokenStream.tokenStartPos());
+ } else if(tokenStream.tokenId() === closeToken) {
+ if(openTokenPositions.length > 0) {
+ openTokenPositions.pop();
+ }
+ }
+ }
+ return -1;
+ };
+ return BraceMatchingManager;
+ })();
+ Services.BraceMatchingManager = BraceMatchingManager;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var SymbolArraySet = (function () {
+ function SymbolArraySet() {
+ this.rtti = SymbolArraySet.rtti_id;
+ this.values = [];
+ }
+ SymbolArraySet.rtti_id = {
+ id: "Services.SymbolArraySet"
+ };
+ SymbolArraySet.prototype.add = function (sym) {
+ if(this.contains(sym)) {
+ return false;
+ }
+ this.values.push(sym);
+ return true;
+ };
+ SymbolArraySet.prototype.contains = function (sym) {
+ return this.values.indexOf(sym) >= 0;
+ };
+ SymbolArraySet.prototype.forEach = function (callback) {
+ this.values.forEach(callback);
+ };
+ SymbolArraySet.prototype.getAll = function () {
+ return this.values;
+ };
+ return SymbolArraySet;
+ })();
+ var SymbolSet = (function () {
+ function SymbolSet() {
+ this.table = new TypeScript.StringHashTable();
+ }
+ SymbolSet.prototype.isSymbolArraySet = function (value) {
+ return value.rtti === SymbolArraySet.rtti_id;
+ };
+ SymbolSet.prototype.add = function (sym) {
+ var key = sym.name;
+ var element = this.table.lookup(key);
+ if(element === null) {
+ this.table.add(key, sym);
+ return true;
+ } else if(this.isSymbolArraySet(element)) {
+ return (element).add(sym);
+ } else {
+ var value = element;
+ if(value === sym) {
+ return false;
+ }
+ var arraySet = new SymbolArraySet();
+ arraySet.add(value);
+ arraySet.add(sym);
+ this.table.addOrUpdate(key, arraySet);
+ return true;
+ }
+ };
+ SymbolSet.prototype.contains = function (sym) {
+ var key = sym.name;
+ var element = this.table.lookup(key);
+ if(element === null) {
+ return false;
+ } else if(this.isSymbolArraySet(element)) {
+ return (element).contains(sym);
+ } else {
+ var value = element;
+ return (value === sym);
+ }
+ };
+ SymbolSet.prototype.isEmpty = function () {
+ return this.table.count() === 0;
+ };
+ SymbolSet.prototype.getAll = function () {
+ var result = [];
+ this.forEach(function (x) {
+ result.push(x);
+ });
+ return result;
+ };
+ SymbolSet.prototype.forEach = function (callback) {
+ var _this = this;
+ this.table.map(function (key, element, ctx) {
+ if(element === null) {
+ } else if(_this.isSymbolArraySet(element)) {
+ (element).forEach(callback);
+ } else {
+ callback(element);
+ }
+ }, null);
+ };
+ SymbolSet.prototype.union = function (other) {
+ var _this = this;
+ other.getAll().forEach(function (x) {
+ _this.add(x);
+ });
+ };
+ return SymbolSet;
+ })();
+ Services.SymbolSet = SymbolSet;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var SymbolTree = (function () {
+ function SymbolTree(host) {
+ this.host = host;
+ this._allTypes = null;
+ }
+ SymbolTree.prototype.findBaseTypesTransitiveClosure = function (sym) {
+ var closure = new Services.SymbolSet();
+ var lastSet = new Services.SymbolSet();
+ lastSet.add(sym);
+ while(!lastSet.isEmpty()) {
+ closure.union(lastSet);
+ lastSet = this.findBaseTypes(closure, lastSet);
+ }
+ return closure;
+ };
+ SymbolTree.prototype.findDerivedTypesTransitiveClosure = function (sym) {
+ var closure = new Services.SymbolSet();
+ var lastSet = new Services.SymbolSet();
+ lastSet.add(sym);
+ while(!lastSet.isEmpty()) {
+ closure.union(lastSet);
+ lastSet = this.findDerivedTypes(closure, lastSet);
+ }
+ return closure;
+ };
+ SymbolTree.prototype.getOverride = function (container, memberSym) {
+ var members = null;
+ if(this.isClass(container)) {
+ members = container.type.instanceType.members;
+ } else if(this.isInterface(container)) {
+ members = container.type.members;
+ }
+ if(members == null) {
+ return null;
+ }
+ var override = members.allMembers.lookup(memberSym.name);
+ if(override == null) {
+ return null;
+ }
+ if((this.isMethod(memberSym) === this.isMethod(override)) && (this.isField(memberSym) === this.isField(override)) && (this.isStatic(memberSym) === this.isStatic(override))) {
+ return override;
+ }
+ return null;
+ };
+ SymbolTree.prototype.getAllTypes = function () {
+ var _this = this;
+ if(this._allTypes === null) {
+ var result = new Services.SymbolSet();
+ this.host.getScripts().forEach(function (script) {
+ TypeScript.walkAST(script, function (path, walker) {
+ if(path.isNameOfClass() || path.isNameOfInterface()) {
+ var sym = (path.ast()).sym;
+ if(sym != null) {
+ if(sym.kind() === TypeScript.SymbolKind.Type) {
+ var typeSym = sym;
+ if(_this.isClass(typeSym) || _this.isInterface(typeSym)) {
+ result.add(typeSym);
+ }
+ }
+ }
+ }
+ if(path.isBodyOfFunction()) {
+ walker.options.goChildren = false;
+ }
+ });
+ });
+ this._allTypes = result.getAll();
+ }
+ return this._allTypes;
+ };
+ SymbolTree.prototype.findBaseTypes = function (closure, lastSet) {
+ var _this = this;
+ var result = new Services.SymbolSet();
+ var symsArray = lastSet.getAll();
+ symsArray.forEach(function (sym) {
+ if(sym.kind() === TypeScript.SymbolKind.Type) {
+ var type = (sym).type;
+ if(type !== null) {
+ if(type.instanceType != null) {
+ type = type.instanceType;
+ }
+ _this.addBaseTypes(closure, result, type.implementsList);
+ _this.addBaseTypes(closure, result, type.extendsList);
+ }
+ }
+ });
+ return result;
+ };
+ SymbolTree.prototype.findDerivedTypes = function (alreadyFound, baseSymbols) {
+ var _this = this;
+ var result = new Services.SymbolSet();
+ this.getAllTypes().forEach(function (candidate) {
+ if(!alreadyFound.contains(candidate)) {
+ if(candidate.kind() === TypeScript.SymbolKind.Type) {
+ var type = (candidate).type;
+ if(type !== null) {
+ if(type.instanceType != null) {
+ type = type.instanceType;
+ }
+ var emptySet = new Services.SymbolSet();
+ var baseTypes = new Services.SymbolSet();
+ _this.addBaseTypes(emptySet, baseTypes, type.implementsList);
+ _this.addBaseTypes(emptySet, baseTypes, type.extendsList);
+ baseTypes.getAll().forEach(function (baseType) {
+ if(baseSymbols.contains(baseType)) {
+ result.add(candidate);
+ }
+ });
+ }
+ }
+ }
+ });
+ return result;
+ };
+ SymbolTree.prototype.addBaseTypes = function (closure, syms, bases) {
+ var _this = this;
+ if(bases == null) {
+ return;
+ }
+ bases.forEach(function (base) {
+ if(base.symbol !== null) {
+ if(!closure.contains(base.symbol)) {
+ if(_this.isDefinition(base.symbol)) {
+ syms.add(base.symbol);
+ }
+ }
+ }
+ });
+ };
+ SymbolTree.prototype.isDefinition = function (sym) {
+ return this.isClass(sym) || this.isInterface(sym);
+ };
+ SymbolTree.prototype.isClass = function (sym) {
+ return sym != null && sym.kind() == TypeScript.SymbolKind.Type && (sym).isClass();
+ };
+ SymbolTree.prototype.isInterface = function (sym) {
+ return sym != null && sym.kind() == TypeScript.SymbolKind.Type && sym.declAST != null && sym.declAST.nodeType === TypeScript.NodeType.InterfaceDeclaration;
+ };
+ SymbolTree.prototype.isMethod = function (sym) {
+ return sym != null && sym.kind() === TypeScript.SymbolKind.Type && (sym).isMethod;
+ };
+ SymbolTree.prototype.isField = function (sym) {
+ return sym != null && sym.kind() === TypeScript.SymbolKind.Field;
+ };
+ SymbolTree.prototype.isStatic = function (sym) {
+ return sym != null && sym.isStatic();
+ };
+ return SymbolTree;
+ })();
+ Services.SymbolTree = SymbolTree;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var OverridesCollector = (function () {
+ function OverridesCollector(symbolTree) {
+ this.symbolTree = symbolTree;
+ }
+ OverridesCollector.prototype.findMemberOverrides = function (memberSym) {
+ return this.findMemberOverridesImpl(memberSym, true, true);
+ };
+ OverridesCollector.prototype.findImplementors = function (sym) {
+ if(this.symbolTree.isClass(sym) || this.symbolTree.isInterface(sym)) {
+ return this.symbolTree.findDerivedTypesTransitiveClosure(sym);
+ } else if(this.symbolTree.isMethod(sym) || this.symbolTree.isField(sym)) {
+ return this.findMemberOverridesImpl(sym, false, true);
+ } else {
+ return new Services.SymbolSet();
+ }
+ };
+ OverridesCollector.prototype.findMemberOverridesImpl = function (memberSym, lookInBases, lookInDerived) {
+ var _this = this;
+ var result = new Services.SymbolSet();
+ result.add(memberSym);
+ if(memberSym.container === null) {
+ return result;
+ }
+ var baseTypes = (lookInBases ? this.symbolTree.findBaseTypesTransitiveClosure(memberSym.container) : new Services.SymbolSet());
+ var derivedTypes = (lookInDerived ? this.symbolTree.findDerivedTypesTransitiveClosure(memberSym.container) : new Services.SymbolSet());
+ var allTypes = new Services.SymbolSet();
+ allTypes.add(memberSym.container);
+ allTypes.union(baseTypes);
+ allTypes.union(derivedTypes);
+ allTypes.getAll().forEach(function (x) {
+ var override = _this.symbolTree.getOverride(x, memberSym);
+ if(override !== null) {
+ result.add(override);
+ }
+ });
+ return result;
+ };
+ return OverridesCollector;
+ })();
+ Services.OverridesCollector = OverridesCollector;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var LanguageServiceShimHostAdapter = (function () {
+ function LanguageServiceShimHostAdapter(shimHost) {
+ this.shimHost = shimHost;
+ }
+ LanguageServiceShimHostAdapter.prototype.information = function () {
+ return this.shimHost.information();
+ };
+ LanguageServiceShimHostAdapter.prototype.debug = function () {
+ return this.shimHost.debug();
+ };
+ LanguageServiceShimHostAdapter.prototype.warning = function () {
+ return this.shimHost.warning();
+ };
+ LanguageServiceShimHostAdapter.prototype.error = function () {
+ return this.shimHost.error();
+ };
+ LanguageServiceShimHostAdapter.prototype.fatal = function () {
+ return this.shimHost.fatal();
+ };
+ LanguageServiceShimHostAdapter.prototype.log = function (s) {
+ this.shimHost.log(s);
+ };
+ LanguageServiceShimHostAdapter.prototype.getCompilationSettings = function () {
+ var settingsJson = this.shimHost.getCompilationSettings();
+ if(settingsJson == null || settingsJson == "") {
+ return null;
+ }
+ var settings = JSON.parse(settingsJson);
+ return settings;
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptCount = function () {
+ return this.shimHost.getScriptCount();
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptId = function (scriptIndex) {
+ return this.shimHost.getScriptId(scriptIndex);
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptSourceText = function (scriptIndex, start, end) {
+ return this.shimHost.getScriptSourceText(scriptIndex, start, end);
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptSourceLength = function (scriptIndex) {
+ return this.shimHost.getScriptSourceLength(scriptIndex);
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptIsResident = function (scriptIndex) {
+ return this.shimHost.getScriptIsResident(scriptIndex);
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptVersion = function (scriptIndex) {
+ return this.shimHost.getScriptVersion(scriptIndex);
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptEditRangeSinceVersion = function (scriptIndex, scriptVersion) {
+ var rangeText = this.shimHost.getScriptEditRangeSinceVersion(scriptIndex, scriptVersion);
+ if(rangeText === null || rangeText === "") {
+ return null;
+ }
+ var minLimDeltaString = rangeText.split(",");
+ return new TypeScript.ScriptEditRange(parseInt(minLimDeltaString[0]), parseInt(minLimDeltaString[1]), parseInt(minLimDeltaString[2]));
+ };
+ return LanguageServiceShimHostAdapter;
+ })();
+ Services.LanguageServiceShimHostAdapter = LanguageServiceShimHostAdapter;
+ function simpleForwardCall(logger, actionDescription, action) {
+ logger.log(actionDescription);
+ var start = Date.now();
+ var result = action();
+ var end = Date.now();
+ logger.log(actionDescription + " completed in " + (end - start) + " msec");
+ if(typeof (result) === "string") {
+ var str = result;
+ logger.log(" result.length=" + str.length + ", result=\"" + TypeScript.stringToLiteral(str, 128) + (str.length > 128 ? "..." : "") + "\"");
+ }
+ return result;
+ }
+ Services.simpleForwardCall = simpleForwardCall;
+ function forwardCall(logger, actionDescription, action, throwOnError) {
+ if (typeof throwOnError === "undefined") { throwOnError = false; }
+ try {
+ return simpleForwardCall(logger, actionDescription, action);
+ } catch (err) {
+ Services.logInternalError(logger, err);
+ if(throwOnError) {
+ throw err;
+ }
+ return "##ERROR##" + err.name + "##" + err.message;
+ }
+ }
+ Services.forwardCall = forwardCall;
+ function forwardJSONCall(logger, actionDescription, action) {
+ try {
+ return simpleForwardCall(logger, actionDescription, action);
+ } catch (err) {
+ Services.logInternalError(logger, err);
+ return _errorToJSON(err);
+ }
+ }
+ Services.forwardJSONCall = forwardJSONCall;
+ function _resultToJSON(result) {
+ return '{"result":' + JSON.stringify(result) + "}";
+ }
+ function _errorToJSON(err) {
+ return '{"error":' + JSON.stringify(err) + "}";
+ }
+ var LanguageServiceShim = (function () {
+ function LanguageServiceShim(host, languageService) {
+ this.host = host;
+ this.languageService = languageService;
+ this.logger = this.host;
+ }
+ LanguageServiceShim.prototype.forwardCall = function (actionDescription, action, throwOnError) {
+ if (typeof throwOnError === "undefined") { throwOnError = false; }
+ return Services.forwardCall(this.logger, actionDescription, action, throwOnError);
+ };
+ LanguageServiceShim.prototype.forwardJSONCall = function (actionDescription, action) {
+ return Services.forwardJSONCall(this.logger, actionDescription, action);
+ };
+ LanguageServiceShim.prototype.dispose = function (dummy) {
+ this.logger.log("dispose()");
+ this.languageService = null;
+ this.logger = null;
+ };
+ LanguageServiceShim.prototype.refresh = function (throwOnError) {
+ var _this = this;
+ this.forwardCall("refresh(" + throwOnError + ")", function () {
+ _this.languageService.refresh();
+ return null;
+ }, throwOnError);
+ };
+ LanguageServiceShim.prototype.getErrors = function (maxCount) {
+ var _this = this;
+ return this.forwardJSONCall("getErrors(" + maxCount + ")", function () {
+ var errors = _this.languageService.getErrors(maxCount);
+ return _resultToJSON(errors);
+ });
+ };
+ LanguageServiceShim.prototype.getScriptErrors = function (fileName, maxCount) {
+ var _this = this;
+ return this.forwardJSONCall("getScriptErrors(" + maxCount + ")", function () {
+ var errors = _this.languageService.getScriptErrors(fileName, maxCount);
+ return _resultToJSON(errors);
+ });
+ };
+ LanguageServiceShim.prototype.getTypeAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getTypeAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var typeInfo = _this.languageService.getTypeAtPosition(fileName, pos);
+ return _resultToJSON(typeInfo);
+ });
+ };
+ LanguageServiceShim.prototype.getNameOrDottedNameSpan = function (fileName, startPos, endPos) {
+ var _this = this;
+ return this.forwardJSONCall("getNameOrDottedNameSpan(\"" + fileName + "\", " + startPos + ", " + endPos + ")", function () {
+ var spanInfo = _this.languageService.getNameOrDottedNameSpan(fileName, startPos, endPos);
+ return _resultToJSON(spanInfo);
+ });
+ };
+ LanguageServiceShim.prototype.getBreakpointStatementAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getBreakpointStatementAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var spanInfo = _this.languageService.getBreakpointStatementAtPosition(fileName, pos);
+ return _resultToJSON(spanInfo);
+ });
+ };
+ LanguageServiceShim.prototype.getSignatureAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getSignatureAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var signatureInfo = _this.languageService.getSignatureAtPosition(fileName, pos);
+ return _resultToJSON(signatureInfo);
+ });
+ };
+ LanguageServiceShim.prototype.getDefinitionAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardCall("getDefinitionAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var definition = _this.languageService.getDefinitionAtPosition(fileName, pos);
+ var result = "";
+ if(definition !== null) {
+ result = definition.unitIndex + '\t' + definition.minChar + '\t' + definition.limChar + '\t' + definition.kind + '\t' + definition.name + '\t' + definition.containerKind + '\t' + definition.containerName;
+ }
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getBraceMatchingAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getBraceMatchingAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var textRanges = _this.languageService.getBraceMatchingAtPosition(fileName, pos);
+ return _resultToJSON(textRanges);
+ });
+ };
+ LanguageServiceShim.prototype.getSmartIndentAtLineNumber = function (fileName, lineNumber, options) {
+ var _this = this;
+ return this.forwardJSONCall("getSmartIndentAtLineNumber(\"" + fileName + "\", " + lineNumber + ")", function () {
+ var localOptions = JSON.parse(options);
+ var columnOffset = _this.languageService.getSmartIndentAtLineNumber(fileName, lineNumber, localOptions);
+ return _resultToJSON({
+ value: columnOffset
+ });
+ });
+ };
+ LanguageServiceShim.prototype.getReferencesAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getReferencesAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var entries = _this.languageService.getReferencesAtPosition(fileName, pos);
+ return _this._referencesToResult(entries);
+ });
+ };
+ LanguageServiceShim.prototype.getOccurrencesAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardCall("getOccurrencesAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var entries = _this.languageService.getOccurrencesAtPosition(fileName, pos);
+ return _this._referencesToResult(entries);
+ });
+ };
+ LanguageServiceShim.prototype.getImplementorsAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getImplementorsAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var entries = _this.languageService.getImplementorsAtPosition(fileName, pos);
+ return _this._referencesToResult(entries);
+ });
+ };
+ LanguageServiceShim.prototype._referencesToResult = function (entries) {
+ var result = "";
+ for(var i = 0; i < entries.length; i++) {
+ var entry = entries[i];
+ result += entry.unitIndex + " " + entry.ast.minChar + " " + entry.ast.limChar + " " + entry.isWriteAccess + "\n";
+ }
+ return result;
+ };
+ LanguageServiceShim.prototype.getCompletionsAtPosition = function (fileName, pos, isMemberCompletion) {
+ var _this = this;
+ return this.forwardJSONCall("getCompletionsAtPosition(\"" + fileName + "\", " + pos + ", " + isMemberCompletion + ")", function () {
+ var completion = _this.languageService.getCompletionsAtPosition(fileName, pos, isMemberCompletion);
+ var result = _resultToJSON(completion);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getFormattingEditsForRange = function (fileName, minChar, limChar, options) {
+ var _this = this;
+ return this.forwardJSONCall("getFormattingEditsForRange(\"" + fileName + "\", " + minChar + ", " + limChar + ")", function () {
+ var localOptions = JSON.parse(options);
+ var edits = _this.languageService.getFormattingEditsForRange(fileName, minChar, limChar, localOptions);
+ var result = _resultToJSON(edits);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getFormattingEditsForDocument = function (fileName, minChar, limChar, options) {
+ var _this = this;
+ return this.forwardJSONCall("getFormattingEditsForDocument(\"" + fileName + "\", " + minChar + ", " + limChar + ")", function () {
+ var localOptions = JSON.parse(options);
+ var edits = _this.languageService.getFormattingEditsForDocument(fileName, minChar, limChar, localOptions);
+ var result = _resultToJSON(edits);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getFormattingEditsOnPaste = function (fileName, minChar, limChar, options) {
+ var _this = this;
+ return this.forwardJSONCall("getFormattingEditsOnPaste(\"" + fileName + "\", " + minChar + ", " + limChar + ")", function () {
+ var localOptions = JSON.parse(options);
+ var edits = _this.languageService.getFormattingEditsOnPaste(fileName, minChar, limChar, localOptions);
+ var result = _resultToJSON(edits);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getFormattingEditsAfterKeystroke = function (fileName, position, key, options) {
+ var _this = this;
+ return this.forwardJSONCall("getFormattingEditsAfterKeystroke(\"" + fileName + "\", " + position + ", \"" + key + "\")", function () {
+ var localOptions = JSON.parse(options);
+ var edits = _this.languageService.getFormattingEditsAfterKeystroke(fileName, position, key, localOptions);
+ var result = _resultToJSON(edits);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getNavigateToItems = function (searchValue) {
+ var _this = this;
+ return this.forwardCall("getNavigateToItems(\"" + searchValue + "\")", function () {
+ var items = _this.languageService.getNavigateToItems(searchValue);
+ var result = _this._navigateToItemsToString(items);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getScriptLexicalStructure = function (fileName) {
+ var _this = this;
+ return this.forwardCall("getScriptLexicalStructure(\"" + fileName + "\")", function () {
+ var items = _this.languageService.getScriptLexicalStructure(fileName);
+ var result = _this._navigateToItemsToString(items);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getOutliningRegions = function (fileName) {
+ var _this = this;
+ return this.forwardCall("getOutliningRegions(\"" + fileName + "\")", function () {
+ var items = _this.languageService.getOutliningRegions(fileName);
+ var result = _this._navigateToItemsToString(items);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.logAST = function (fileName) {
+ var _this = this;
+ this.forwardCall("logAST(\"" + fileName + "\")", function () {
+ _this.languageService.logAST(fileName);
+ return null;
+ });
+ };
+ LanguageServiceShim.prototype.logSyntaxAST = function (fileName) {
+ var _this = this;
+ this.forwardCall("logSyntaxAST(\"" + fileName + "\")", function () {
+ _this.languageService.logSyntaxAST(fileName);
+ return null;
+ });
+ };
+ LanguageServiceShim.prototype.getEmitOutput = function (fileName) {
+ var _this = this;
+ return this.forwardJSONCall("getEmitOutput(\"" + fileName + "\")", function () {
+ var output = _this.languageService.getEmitOutput(fileName);
+ var result = _resultToJSON(output);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype._navigateToItemsToString = function (items) {
+ var result = "";
+ for(var i = 0; i < items.length; i++) {
+ var item = items[i];
+ result += item.name + "\t" + item.kind + "\t" + item.kindModifiers + "\t" + item.containerName + "\t" + item.containerKind + "\t" + item.matchKind + "\t" + item.unitIndex + "\t" + item.minChar + "\t" + item.limChar + "\n";
+ }
+ return result;
+ };
+ return LanguageServiceShim;
+ })();
+ Services.LanguageServiceShim = LanguageServiceShim;
+ var ClassifierShim = (function () {
+ function ClassifierShim(host) {
+ this.host = host;
+ this.classifier = new Services.Classifier(this.host);
+ }
+ ClassifierShim.prototype.getClassificationsForLine = function (text, lexState) {
+ var classification = this.classifier.getClassificationsForLine(text, lexState);
+ var items = classification.entries;
+ var result = "";
+ for(var i = 0; i < items.length; i++) {
+ result += items[i].length + "\n";
+ result += items[i].classification + "\n";
+ }
+ result += classification.finalLexState;
+ return result;
+ };
+ return ClassifierShim;
+ })();
+ Services.ClassifierShim = ClassifierShim;
+ var CoreServicesShim = (function () {
+ function CoreServicesShim(host) {
+ this.host = host;
+ this.logger = this.host.logger;
+ this.services = new Services.CoreServices(this.host);
+ }
+ CoreServicesShim.prototype.forwardCall = function (actionDescription, action, throwOnError) {
+ if (typeof throwOnError === "undefined") { throwOnError = false; }
+ return Services.forwardCall(this.logger, actionDescription, action, throwOnError);
+ };
+ CoreServicesShim.prototype.forwardJSONCall = function (actionDescription, action) {
+ return Services.forwardJSONCall(this.logger, actionDescription, action);
+ };
+ CoreServicesShim.prototype.getPreProcessedFileInfo = function (scriptId, sourceText) {
+ var _this = this;
+ return this.forwardJSONCall("getPreProcessedFileInfo(\"" + scriptId + "\")", function () {
+ var result = _this.services.getPreProcessedFileInfo(scriptId, sourceText);
+ return _resultToJSON(result);
+ });
+ };
+ CoreServicesShim.prototype.getDefaultCompilationSettings = function () {
+ var _this = this;
+ return this.forwardJSONCall("getDefaultCompilationSettings()", function () {
+ var result = _this.services.getDefaultCompilationSettings();
+ return _resultToJSON(result);
+ });
+ };
+ CoreServicesShim.prototype.dumpMemory = function (dummy) {
+ var _this = this;
+ return this.forwardCall("dumpMemory()", function () {
+ return _this.services.dumpMemory();
+ });
+ };
+ CoreServicesShim.prototype.getMemoryInfo = function (dummy) {
+ var _this = this;
+ return this.forwardJSONCall("getMemoryInfo()", function () {
+ var result = _this.services.getMemoryInfo();
+ return _resultToJSON(result);
+ });
+ };
+ return CoreServicesShim;
+ })();
+ Services.CoreServicesShim = CoreServicesShim;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ function copyDataObject(dst, src) {
+ for(var e in dst) {
+ if(typeof dst[e] == "object") {
+ copyDataObject(dst[e], src[e]);
+ } else if(typeof dst[e] != "function") {
+ dst[e] = src[e];
+ }
+ }
+ return dst;
+ }
+ Services.copyDataObject = copyDataObject;
+ function compareDataObjects(dst, src) {
+ for(var e in dst) {
+ if(typeof dst[e] == "object") {
+ if(!compareDataObjects(dst[e], src[e])) {
+ return false;
+ }
+ } else if(typeof dst[e] != "function") {
+ if(dst[e] !== src[e]) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ Services.compareDataObjects = compareDataObjects;
+ var TypeScriptServicesFactory = (function () {
+ function TypeScriptServicesFactory() { }
+ TypeScriptServicesFactory.prototype.createLanguageService = function (host) {
+ try {
+ return new Services.LanguageService(host);
+ } catch (err) {
+ Services.logInternalError(host, err);
+ throw err;
+ }
+ };
+ TypeScriptServicesFactory.prototype.createLanguageServiceShim = function (host) {
+ try {
+ var hostAdapter = new Services.LanguageServiceShimHostAdapter(host);
+ var languageService = this.createLanguageService(hostAdapter);
+ return new Services.LanguageServiceShim(host, languageService);
+ } catch (err) {
+ Services.logInternalError(host, err);
+ throw err;
+ }
+ };
+ TypeScriptServicesFactory.prototype.createClassifier = function (host) {
+ try {
+ return new Services.Classifier(host);
+ } catch (err) {
+ Services.logInternalError(host, err);
+ throw err;
+ }
+ };
+ TypeScriptServicesFactory.prototype.createClassifierShim = function (host) {
+ try {
+ return new Services.ClassifierShim(host);
+ } catch (err) {
+ Services.logInternalError(host, err);
+ throw err;
+ }
+ };
+ TypeScriptServicesFactory.prototype.createCoreServices = function (host) {
+ try {
+ return new Services.CoreServices(host);
+ } catch (err) {
+ Services.logInternalError(host.logger, err);
+ throw err;
+ }
+ };
+ TypeScriptServicesFactory.prototype.createCoreServicesShim = function (host) {
+ try {
+ return new Services.CoreServicesShim(host);
+ } catch (err) {
+ Services.logInternalError(host.logger, err);
+ throw err;
+ }
+ };
+ return TypeScriptServicesFactory;
+ })();
+ Services.TypeScriptServicesFactory = TypeScriptServicesFactory;
+})(Services || (Services = {}));
+var Diff;
+(function (Diff) {
+ (function (SegmentType) {
+ SegmentType._map = [];
+ SegmentType._map[0] = "Unchanged";
+ SegmentType.Unchanged = 0;
+ SegmentType._map[1] = "Added";
+ SegmentType.Added = 1;
+ SegmentType._map[2] = "Removed";
+ SegmentType.Removed = 2;
+ SegmentType._map[3] = "MovedFrom";
+ SegmentType.MovedFrom = 3;
+ SegmentType._map[4] = "MovedTo";
+ SegmentType.MovedTo = 4;
+ })(Diff.SegmentType || (Diff.SegmentType = {}));
+ var SegmentType = Diff.SegmentType;
+ (function (UnicodeCategory) {
+ UnicodeCategory._map = [];
+ UnicodeCategory._map[0] = "SpaceSeparator";
+ UnicodeCategory.SpaceSeparator = 0;
+ UnicodeCategory._map[1] = "LowercaseLetter";
+ UnicodeCategory.LowercaseLetter = 1;
+ })(Diff.UnicodeCategory || (Diff.UnicodeCategory = {}));
+ var UnicodeCategory = Diff.UnicodeCategory;
+ var Segment = (function () {
+ function Segment(content, type) {
+ if (typeof content === "undefined") { content = ''; }
+ if (typeof type === "undefined") { type = SegmentType.Unchanged; }
+ this.content = content;
+ this.type = type;
+ }
+ return Segment;
+ })();
+ Diff.Segment = Segment;
+ var Region = (function () {
+ function Region(index, length, type) {
+ this.index = index;
+ this.length = length;
+ this.type = type;
+ }
+ return Region;
+ })();
+ Diff.Region = Region;
+ var Chunk = (function () {
+ function Chunk(content, delimiterContent) {
+ this.content = content;
+ this.delimiterContent = delimiterContent;
+ this.hashCode = "~!!" + content;
+ this.matchingIndex = -1;
+ this.innerDiff = null;
+ }
+ Chunk.prototype.mergedContent = function () {
+ return this.content + this.delimiterContent;
+ };
+ Chunk.prototype.equals = function (otherChunk) {
+ if(otherChunk == null) {
+ throw new Error("otherChunk is null");
+ }
+ if(this.hashCode != otherChunk.hashCode) {
+ return false;
+ }
+ return this.content === otherChunk.content;
+ };
+ Chunk.isDelimiter = function isDelimiter(c, delimiters) {
+ return delimiters.indexOf(c) >= 0;
+ };
+ Chunk.Split = function Split(content, delimiters) {
+ var set = [];
+ var currentIndex, currentLength;
+ var index = 0;
+ var length = content.length;
+ var delimiterCount = 0;
+ while(index < length) {
+ currentIndex = index;
+ currentLength = 0;
+ while(index < length && !Chunk.isDelimiter(content.substr(index, 1), delimiters)) {
+ currentLength++;
+ index++;
+ }
+ delimiterCount = 0;
+ while(index < length && Chunk.isDelimiter(content.substr(index, 1), delimiters)) {
+ currentLength++;
+ index++;
+ delimiterCount++;
+ }
+ set.push(new Chunk(content.substr(currentIndex, currentLength - delimiterCount), content.substr(currentIndex + currentLength - delimiterCount, delimiterCount)));
+ }
+ return set;
+ };
+ Chunk.SplitSeparateDelimiters = function SplitSeparateDelimiters(content, delimiters) {
+ if(content == null || content.length == 0) {
+ return [];
+ }
+ var set = [];
+ var wantDelimiter = Chunk.isDelimiter(content[0], delimiters);
+ var currentIndex, currentLength;
+ var index = 0;
+ var length = content.length;
+ while(index < length) {
+ currentIndex = index;
+ currentLength = 0;
+ while(index < length && wantDelimiter == Chunk.isDelimiter(content[index], delimiters)) {
+ currentLength++;
+ index++;
+ }
+ wantDelimiter = !wantDelimiter;
+ set.push(new Chunk(content.substr(currentIndex, currentLength), ''));
+ }
+ return set;
+ };
+ Chunk.SplitInner = function SplitInner(content) {
+ return Chunk.SplitCategory(content);
+ };
+ Chunk.SplitCategory = function SplitCategory(content) {
+ if(content == null || content.length == 0) {
+ return [];
+ }
+ var set = [];
+ var categoryToMatch = Chunk.GetCategory(content[0]);
+ var currentIndex, currentLength;
+ var index = 0;
+ var length = content.length;
+ while(index < length) {
+ currentIndex = index;
+ currentLength = 1;
+ index++;
+ while(index < length && Chunk.CategoryMatches(Chunk.GetCategory(content[index]), categoryToMatch)) {
+ currentLength++;
+ index++;
+ }
+ if(index < length) {
+ categoryToMatch = Chunk.GetCategory(content[index]);
+ }
+ set.push(new Chunk(content.substr(currentIndex, currentLength), ''));
+ }
+ return set;
+ };
+ Chunk.CategoryMatches = function CategoryMatches(left, right) {
+ if(left == UnicodeCategory.SpaceSeparator || right == UnicodeCategory.SpaceSeparator) {
+ return false;
+ }
+ return left == right;
+ };
+ Chunk.GetCategory = function GetCategory(c) {
+ if(c === ' ' || c === '\r' || c === '\n' || c === '\t') {
+ return UnicodeCategory.SpaceSeparator;
+ } else {
+ return UnicodeCategory.LowercaseLetter;
+ }
+ };
+ Chunk.SplitEveryChar = function SplitEveryChar(content) {
+ var set = [];
+ for(var i = 0; i < content.length; ++i) {
+ set.push(new Chunk(content[i], ''));
+ }
+ return set;
+ };
+ Chunk.prototype.toString = function () {
+ return 'NYI?';
+ };
+ return Chunk;
+ })();
+ Diff.Chunk = Chunk;
+ var UniquenessEntry = (function () {
+ function UniquenessEntry(index, content) {
+ this.index = index;
+ this.content = content;
+ this.MatchCount = 1;
+ }
+ UniquenessEntry.prototype.equals = function (other) {
+ return this.content == other.content;
+ };
+ UniquenessEntry.prototype.Increment = function () {
+ this.MatchCount++;
+ };
+ return UniquenessEntry;
+ })();
+ var SegmentBuilder = (function () {
+ function SegmentBuilder() {
+ this.segmentSet = [];
+ }
+ SegmentBuilder.prototype.AddSegment = function (content, type) {
+ if(this.segmentExists && this.currentType == type) {
+ this.currentContent += content;
+ } else {
+ if(this.segmentExists) {
+ var currentSegment = new Segment();
+ currentSegment.content = this.currentContent;
+ currentSegment.type = this.currentType;
+ this.segmentSet.push(currentSegment);
+ }
+ this.segmentExists = true;
+ this.currentContent = content;
+ this.currentType = type;
+ }
+ };
+ SegmentBuilder.prototype.FlushSegment = function () {
+ if(this.segmentExists) {
+ this.segmentExists = false;
+ var currentSegment = new Segment();
+ currentSegment.content = this.currentContent;
+ currentSegment.type = this.currentType;
+ this.segmentSet.push(currentSegment);
+ }
+ };
+ SegmentBuilder.prototype.GetSegments = function () {
+ this.FlushSegment();
+ return this.segmentSet;
+ };
+ return SegmentBuilder;
+ })();
+ var InnerDiff = (function () {
+ function InnerDiff(oldContent, newContent) {
+ var oldChunks = Chunk.SplitInner(oldContent);
+ var newChunks = Chunk.SplitInner(newContent);
+ StringDiff.Compare(oldChunks, 0, oldChunks.length - 1, newChunks, 0, newChunks.length - 1);
+ this.Segments = StringDiff.CompressArraysToSegments(oldChunks, newChunks);
+ }
+ return InnerDiff;
+ })();
+ Diff.InnerDiff = InnerDiff;
+ var StringDiff = (function () {
+ function StringDiff(oldContent, newContent) {
+ this.regionsGenerated = false;
+ this.segmentSet = [];
+ var delimitersToUse = '\n\r';
+ var useNestedAlgorithm = true;
+ var oldChunks = Chunk.Split(oldContent, delimitersToUse.split(''));
+ var newChunks = Chunk.Split(newContent, delimitersToUse.split(''));
+ StringDiff.Compare(oldChunks, 0, oldChunks.length - 1, newChunks, 0, newChunks.length - 1);
+ if(useNestedAlgorithm) {
+ StringDiff.PerformNestedDiff(oldChunks, newChunks);
+ }
+ this.segmentSet = StringDiff.CompressArraysToSegments(oldChunks, newChunks);
+ this.GenerateStringsAndRegions();
+ }
+ StringDiff.Compare = function Compare(oldContent, oldStart, oldEnd, newContent, newStart, newEnd) {
+ var oldTable = StringDiff.BuildUniquenessTable(oldContent, oldStart, oldEnd);
+ var newTable = StringDiff.BuildUniquenessTable(newContent, newStart, newEnd);
+ for(var i = newStart; i <= newEnd; ++i) {
+ var newEntries = (newTable[newContent[i].hashCode]);
+ var oldEntries = (oldTable[newContent[i].hashCode]);
+ if(newEntries && oldEntries) {
+ var foundIt = false;
+ for(var x = 0; x < newEntries.length; x++) {
+ var newEntry = newEntries[x];
+ for(var y = 0; y < oldEntries.length; y++) {
+ var oldEntry = oldEntries[y];
+ if(newEntry && oldEntry && newEntry.MatchCount == 1 && oldEntry.MatchCount == 1 && (newEntry.content.localeCompare(oldEntry.content) === 0)) {
+ var oldIndex = oldEntry.index;
+ newContent[i].matchingIndex = oldIndex;
+ oldContent[oldIndex].matchingIndex = i;
+ foundIt = true;
+ break;
+ }
+ }
+ if(foundIt) {
+ break;
+ }
+ }
+ }
+ }
+ if(oldStart <= oldEnd && newStart <= newEnd) {
+ StringDiff.TryMatch(oldContent, oldStart, newContent, newStart);
+ StringDiff.TryMatch(oldContent, oldEnd, newContent, newEnd);
+ }
+ for(var i = newStart; i < newEnd; ++i) {
+ var j = newContent[i].matchingIndex;
+ if(j != -1 && j < oldEnd && j >= oldStart) {
+ if(oldContent[j].matchingIndex == i) {
+ StringDiff.TryMatch(oldContent, j + 1, newContent, i + 1);
+ }
+ }
+ }
+ for(var i = newEnd; i > newStart; --i) {
+ var j = newContent[i].matchingIndex;
+ if(j != -1 && j <= oldEnd && j > oldStart) {
+ if(oldContent[j].matchingIndex == i) {
+ StringDiff.TryMatch(oldContent, j - 1, newContent, i - 1);
+ }
+ }
+ }
+ };
+ StringDiff.TryMatch = function TryMatch(oldContent, oldIndex, newContent, newIndex) {
+ var newChunk = newContent[newIndex];
+ var oldChunk = oldContent[oldIndex];
+ if(newChunk.matchingIndex == -1 && oldChunk.matchingIndex == -1) {
+ if(newChunk.content === oldChunk.content) {
+ newChunk.matchingIndex = oldIndex;
+ oldChunk.matchingIndex = newIndex;
+ }
+ }
+ };
+ StringDiff.BuildUniquenessTable = function BuildUniquenessTable(content, start, end) {
+ var table = {
+ };
+ for(var i = start; i <= end; ++i) {
+ var entries = table[content[i].hashCode];
+ if(entries == null) {
+ entries = [];
+ }
+ var hasMatch = false;
+ for(var k = 0; k < entries.length; k++) {
+ if(entries[k].content.localeCompare(content[i].content) === 0) {
+ hasMatch = true;
+ entries[k].Increment();
+ break;
+ }
+ }
+ if(!hasMatch) {
+ var newEntry = new UniquenessEntry(i, content[i].content);
+ entries.push(newEntry);
+ }
+ table[content[i].hashCode] = entries;
+ }
+ return table;
+ };
+ StringDiff.PerformNestedDiff = function PerformNestedDiff(oldContent, newContent) {
+ if(oldContent.length > 0 && newContent.length > 0) {
+ StringDiff.TryInnerMatch(oldContent, 0, newContent, 0);
+ StringDiff.TryInnerMatch(oldContent, oldContent.length - 1, newContent, newContent.length - 1);
+ }
+ for(var i = 0; i < newContent.length - 1; ++i) {
+ var j = newContent[i].matchingIndex;
+ if(j != -1 && j < oldContent.length - 1 && j >= 0) {
+ if(oldContent[j].matchingIndex == i) {
+ StringDiff.TryInnerMatch(oldContent, j + 1, newContent, i + 1);
+ }
+ }
+ }
+ for(var i = newContent.length - 1; i > 0; --i) {
+ var j = newContent[i].matchingIndex;
+ if(j != -1 && j < oldContent.length && j > 0) {
+ if(oldContent[j].matchingIndex == i) {
+ StringDiff.TryInnerMatch(oldContent, j - 1, newContent, i - i);
+ }
+ }
+ }
+ };
+ StringDiff.TryInnerMatch = function TryInnerMatch(oldContent, oldIndex, newContent, newIndex) {
+ var newChunk = newContent[newIndex];
+ var oldChunk = oldContent[oldIndex];
+ if(newChunk.matchingIndex == -1 && oldChunk.matchingIndex == -1) {
+ var difference = new InnerDiff(oldContent[oldIndex].content, newContent[newIndex].content);
+ if(StringDiff.AreSimilarEnough(difference)) {
+ newChunk.innerDiff = difference;
+ oldChunk.innerDiff = difference;
+ newChunk.matchingIndex = oldIndex;
+ oldChunk.matchingIndex = newIndex;
+ }
+ }
+ };
+ StringDiff.AreSimilarEnough = function AreSimilarEnough(difference) {
+ var identicalChars = 0;
+ var differentChars = 0;
+ var addedCount = 0;
+ var removedCount = 0;
+ var movedCount = 0;
+ for(var i = 0; i < difference.Segments.length; i++) {
+ var s = difference.Segments[i];
+ switch(s.type) {
+ case SegmentType.Added:
+ addedCount++;
+ break;
+ case SegmentType.Removed:
+ removedCount++;
+ break;
+ case SegmentType.MovedFrom:
+ movedCount++;
+ break;
+ case SegmentType.MovedTo:
+ movedCount++;
+ break;
+ }
+ if(s.content.trim().length == 0) {
+ continue;
+ }
+ if(s.type == SegmentType.Unchanged) {
+ identicalChars += s.content.length * 2;
+ } else {
+ differentChars += s.content.length;
+ }
+ }
+ var totalChars = identicalChars + differentChars;
+ if(totalChars == 0) {
+ return true;
+ }
+ if(removedCount == 0 && movedCount == 0) {
+ return true;
+ }
+ if(addedCount == 0 && movedCount == 0) {
+ return true;
+ }
+ return (identicalChars / totalChars) > 0.50;
+ };
+ StringDiff.CompressArraysToSegments = function CompressArraysToSegments(oldContent, newContent) {
+ var builder = new SegmentBuilder();
+ var oldIndex = 0;
+ var newIndex = 0;
+ while(oldIndex < oldContent.length && newIndex < newContent.length) {
+ if(oldContent[oldIndex].matchingIndex == newIndex) {
+ if(newContent[newIndex].innerDiff == null) {
+ builder.AddSegment(newContent[newIndex].mergedContent(), SegmentType.Unchanged);
+ } else {
+ for(var i = 0; i < newContent[newIndex].innerDiff.Segments.length; i++) {
+ var s = newContent[newIndex].innerDiff.Segments[i];
+ builder.AddSegment(s.content, s.type);
+ }
+ }
+ oldIndex++;
+ newIndex++;
+ } else if(oldContent[oldIndex].matchingIndex == -1) {
+ builder.AddSegment(oldContent[oldIndex].mergedContent(), SegmentType.Removed);
+ oldIndex++;
+ } else if(newContent[newIndex].matchingIndex == -1) {
+ builder.AddSegment(newContent[newIndex].mergedContent(), SegmentType.Added);
+ newIndex++;
+ } else if(oldContent[oldIndex].matchingIndex < newIndex) {
+ builder.AddSegment(oldContent[oldIndex].mergedContent(), SegmentType.MovedFrom);
+ oldIndex++;
+ } else if(newContent[newIndex].matchingIndex < oldIndex) {
+ builder.AddSegment(newContent[newIndex].mergedContent(), SegmentType.MovedTo);
+ newIndex++;
+ } else {
+ var linesOnLeftBeforeUnchanged = newContent[newIndex].matchingIndex - oldIndex;
+ var linesOnRightBeforeUnchanged = oldContent[oldIndex].matchingIndex - newIndex;
+ if(linesOnLeftBeforeUnchanged < linesOnRightBeforeUnchanged) {
+ builder.AddSegment(oldContent[oldIndex].mergedContent(), SegmentType.MovedFrom);
+ oldIndex++;
+ } else {
+ builder.AddSegment(newContent[newIndex].mergedContent(), SegmentType.MovedTo);
+ newIndex++;
+ }
+ }
+ }
+ while(oldIndex < oldContent.length) {
+ if(oldContent[oldIndex].matchingIndex == -1) {
+ builder.AddSegment(oldContent[oldIndex].mergedContent(), SegmentType.Removed);
+ } else {
+ builder.AddSegment(oldContent[oldIndex].mergedContent(), SegmentType.MovedFrom);
+ }
+ oldIndex++;
+ }
+ while(newIndex < newContent.length) {
+ if(newContent[newIndex].matchingIndex == -1) {
+ builder.AddSegment(newContent[newIndex].mergedContent(), SegmentType.Added);
+ } else {
+ builder.AddSegment(newContent[newIndex].mergedContent(), SegmentType.MovedTo);
+ }
+ newIndex++;
+ }
+ return builder.GetSegments();
+ };
+ StringDiff.prototype.GenerateStringsAndRegions = function () {
+ if(this.regionsGenerated === false) {
+ this.regionsGenerated = true;
+ var MergedHtml = '';
+ var MergedText = '';
+ var OldText = '';
+ var NewText = '';
+ var Regions = [];
+ MergedHtml += StringDiff.htmlPrefix();
+ for(var i = 0; i < this.segmentSet.length; i++) {
+ var segment = this.segmentSet[i];
+ var newRegion = new Region(MergedText.length, segment.content.length, segment.type);
+ Regions.push(newRegion);
+ MergedText += segment.content;
+ switch(segment.type) {
+ case SegmentType.Added:
+ OldText += (StringDiff.whitespaceEquivalent(segment.content));
+ NewText += (segment.content);
+ MergedHtml += (StringDiff.addedStringHtml(segment.content));
+ break;
+ case SegmentType.MovedTo:
+ OldText += (StringDiff.whitespaceEquivalent(segment.content));
+ NewText += (segment.content);
+ MergedHtml += (StringDiff.movedToStringHtml(segment.content));
+ break;
+ case SegmentType.Removed:
+ OldText += (segment.content);
+ NewText += (StringDiff.whitespaceEquivalent(segment.content));
+ MergedHtml += (StringDiff.removedStringHtml(segment.content));
+ break;
+ case SegmentType.MovedFrom:
+ OldText += (segment.content);
+ NewText += (StringDiff.whitespaceEquivalent(segment.content));
+ MergedHtml += (StringDiff.movedFromStringHtml(segment.content));
+ break;
+ default:
+ OldText += (segment.content);
+ NewText += (segment.content);
+ MergedHtml += (StringDiff.unchangedStringHtml(segment.content));
+ break;
+ }
+ }
+ MergedHtml += StringDiff.htmlSuffix();
+ this.mergedHtml = MergedHtml;
+ this.mergedOutput = MergedText;
+ this.oldOutput = OldText;
+ this.newOutput = NewText;
+ this.regions = Regions;
+ }
+ };
+ StringDiff.htmlPrefix = function htmlPrefix() {
+ var content = '';
+ return content;
+ };
+ StringDiff.htmlSuffix = function htmlSuffix() {
+ return '';
+ };
+ StringDiff.addedStringHtml = function addedStringHtml(text) {
+ return "" + StringDiff.fullHtmlEncode(text) + "";
+ };
+ StringDiff.removedStringHtml = function removedStringHtml(text) {
+ return "" + StringDiff.fullHtmlEncode(text) + "";
+ };
+ StringDiff.movedFromStringHtml = function movedFromStringHtml(text) {
+ return "" + StringDiff.fullHtmlEncode(text) + "";
+ };
+ StringDiff.movedToStringHtml = function movedToStringHtml(text) {
+ return "" + StringDiff.fullHtmlEncode(text) + "";
+ };
+ StringDiff.unchangedStringHtml = function unchangedStringHtml(text) {
+ return StringDiff.fullHtmlEncode(text);
+ };
+ StringDiff.fullHtmlEncode = function fullHtmlEncode(text) {
+ return text.replace('<', '<').replace(/\n/g, '
').replace(/ /g, ' ').replace(/\t/g, ' ');
+ };
+ StringDiff.whitespaceEquivalent = function whitespaceEquivalent(input) {
+ return input.replace(/./g, ' ');
+ };
+ return StringDiff;
+ })();
+ Diff.StringDiff = StringDiff;
+})(Diff || (Diff = {}));
+var global = Function("return this").call(null);
+function switchToForwardSlashes(path) {
+ return path.replace(/\\/g, "/");
+}
+function filePath(fullPath) {
+ fullPath = switchToForwardSlashes(fullPath);
+ var components = fullPath.split("/");
+ var path = components.slice(0, components.length - 1);
+ return path.join("/") + "/";
+}
+var CService;
+(function (CService) {
+ CService.userSpecifiedroot = "";
+ function readFile(path) {
+ return IO.readFile(CService.userSpecifiedroot + path);
+ }
+ CService.readFile = readFile;
+ (function (Compiler) {
+ var WriterAggregator = (function () {
+ function WriterAggregator() {
+ this.lines = [];
+ this.currentLine = "";
+ }
+ WriterAggregator.prototype.Write = function (str) {
+ this.currentLine += str;
+ };
+ WriterAggregator.prototype.WriteLine = function (str) {
+ this.lines.push(this.currentLine + str);
+ this.currentLine = "";
+ };
+ WriterAggregator.prototype.Close = function () {
+ this.lines.push(this.currentLine);
+ this.currentLine = "";
+ };
+ WriterAggregator.prototype.reset = function () {
+ this.lines = [];
+ this.currentLine = "";
+ };
+ return WriterAggregator;
+ })();
+ Compiler.WriterAggregator = WriterAggregator;
+ var libFolder = global['WScript'] ? TypeScript.filePath(global['WScript'].ScriptFullName) : (__dirname + '/');
+ Compiler.libText = IO ? IO.readFile(libFolder + "lib.d.ts") : '';
+ var stdout = new WriterAggregator();
+ var stderr = new WriterAggregator();
+ var currentUnit = 0;
+ var maxUnit = 0;
+ Compiler.compiler;
+ recreate();
+ var Type = (function () {
+ function Type(type, code, identifier) {
+ this.type = type;
+ this.code = code;
+ this.identifier = identifier;
+ }
+ Type.prototype.normalizeToArray = function (arg) {
+ if((Array.isArray && Array.isArray(arg)) || arg instanceof Array) {
+ return arg;
+ }
+ return [
+ arg
+ ];
+ };
+ Type.prototype.compilesOk = function (testCode) {
+ var errors = null;
+ compileString(testCode, 'test.ts', function (compilerResult) {
+ errors = compilerResult.errors;
+ });
+ return errors.length === 0;
+ };
+ Type.prototype.isSubtypeOf = function (other) {
+ var testCode = 'class __test1__ {\n';
+ testCode += ' public test() {\n';
+ testCode += ' ' + other.code + ';\n';
+ testCode += ' return ' + other.identifier + ';\n';
+ testCode += ' }\n';
+ testCode += '}\n';
+ testCode += 'class __test2__ extends __test1__ {\n';
+ testCode += ' public test() {\n';
+ testCode += ' ' + this.code + ';\n';
+ testCode += ' return ' + other.identifier + ';\n';
+ testCode += ' }\n';
+ testCode += '}\n';
+ return this.compilesOk(testCode);
+ };
+ Type.prototype.isIdenticalTo = function (other) {
+ var testCode = 'module __test1__ {\n';
+ testCode += ' ' + this.code + ';\n';
+ testCode += ' export var __val__ = ' + this.identifier + ';\n';
+ testCode += '}\n';
+ testCode += 'var __test1__val__ = __test1__.__val__;\n';
+ testCode += 'module __test2__ {\n';
+ testCode += ' ' + other.code + ';\n';
+ testCode += ' export var __val__ = ' + other.identifier + ';\n';
+ testCode += '}\n';
+ testCode += 'var __test2__val__ = __test2__.__val__;\n';
+ testCode += 'function __test__function__() { if(true) { return __test1__val__ }; return __test2__val__; }';
+ return this.compilesOk(testCode);
+ };
+ Type.prototype.assertSubtypeOf = function (others) {
+ others = this.normalizeToArray(others);
+ for(var i = 0; i < others.length; i++) {
+ if(!this.isSubtypeOf(others[i])) {
+ throw new Error("Expected " + this.type + " to be a subtype of " + others[i].type);
+ }
+ }
+ };
+ Type.prototype.assertNotSubtypeOf = function (others) {
+ others = this.normalizeToArray(others);
+ for(var i = 0; i < others.length; i++) {
+ if(this.isSubtypeOf(others[i])) {
+ throw new Error("Expected " + this.type + " to be a subtype of " + others[i].type);
+ }
+ }
+ };
+ Type.prototype.assertIdenticalTo = function (other) {
+ if(!this.isIdenticalTo(other)) {
+ throw new Error("Expected " + this.type + " to be identical to " + other.type);
+ }
+ };
+ Type.prototype.assertNotIdenticalTo = function (other) {
+ if(!this.isIdenticalTo(other)) {
+ throw new Error("Expected " + this.type + " to not be identical to " + other.type);
+ }
+ };
+ Type.prototype.isAssignmentCompatibleWith = function (other) {
+ var testCode = 'module __test1__ {\n';
+ testCode += ' ' + this.code + ';\n';
+ testCode += ' export var __val__ = ' + this.identifier + ';\n';
+ testCode += '}\n';
+ testCode += 'var __test1__val__ = __test1__.__val__;\n';
+ testCode += 'module __test2__ {\n';
+ testCode += ' export ' + other.code + ';\n';
+ testCode += ' export var __val__ = ' + other.identifier + ';\n';
+ testCode += '}\n';
+ testCode += 'var __test2__val__ = __test2__.__val__;\n';
+ testCode += '__test2__val__ = __test1__val__;';
+ return this.compilesOk(testCode);
+ };
+ Type.prototype.assertAssignmentCompatibleWith = function (others) {
+ others = this.normalizeToArray(others);
+ for(var i = 0; i < others.length; i++) {
+ var other = others[i];
+ if(!this.isAssignmentCompatibleWith(other)) {
+ throw new Error("Expected " + this.type + " to be assignment compatible with " + other.type);
+ }
+ }
+ };
+ Type.prototype.assertNotAssignmentCompatibleWith = function (others) {
+ others = this.normalizeToArray(others);
+ for(var i = 0; i < others.length; i++) {
+ var other = others[i];
+ if(this.isAssignmentCompatibleWith(other)) {
+ throw new Error("Expected " + this.type + " to not be assignment compatible with " + other.type);
+ }
+ }
+ };
+ return Type;
+ })();
+ Compiler.Type = Type;
+ var TypeFactory = (function () {
+ function TypeFactory() {
+ this.any = this.get('var x : any', 'x');
+ this.number = this.get('var x : number', 'x');
+ this.string = this.get('var x : string', 'x');
+ this.bool = this.get('var x : bool', 'x');
+ }
+ TypeFactory.prototype.get = function (code, identifier) {
+ var errors = null;
+ compileString(code, 'test.ts', function (compilerResult) {
+ errors = compilerResult.errors;
+ });
+ if(errors.length > 0) {
+ throw new Error("Type definition contains errors: " + errors.join(","));
+ }
+ var script = Compiler.compiler.scripts.members[1];
+ var enclosingScopeContext = TypeScript.findEnclosingScopeAt(new TypeScript.NullLogger(), script, new TypeScript.StringSourceText(code), 0, false);
+ var entries = new TypeScript.ScopeTraversal(Compiler.compiler).getScopeEntries(enclosingScopeContext);
+ for(var i = 0; i < entries.length; i++) {
+ if(entries[i].name === identifier) {
+ return new Type(entries[i].type, code, identifier);
+ }
+ }
+ };
+ return TypeFactory;
+ })();
+ Compiler.TypeFactory = TypeFactory;
+ function generateDeclFile(code, verifyNoDeclFile) {
+ reset();
+ Compiler.compiler.settings.generateDeclarationFiles = true;
+ var oldOutputMany = Compiler.compiler.settings.outputMany;
+ try {
+ addUnit(code);
+ Compiler.compiler.reTypeCheck();
+ var outputs = {
+ };
+ Compiler.compiler.settings.outputMany = true;
+ Compiler.compiler.emitDeclarationFile(function (fn) {
+ outputs[fn] = new Compiler.WriterAggregator();
+ return outputs[fn];
+ });
+ for(var fn in outputs) {
+ if(fn.indexOf('.d.ts') >= 0) {
+ var writer = outputs[fn];
+ writer.Close();
+ if(verifyNoDeclFile) {
+ throw new Error('Compilation should not produce ' + fn);
+ }
+ return writer.lines.join('\n');
+ }
+ }
+ if(!verifyNoDeclFile) {
+ throw new Error('Compilation did not produced .d.ts files');
+ }
+ }finally {
+ Compiler.compiler.settings.generateDeclarationFiles = false;
+ Compiler.compiler.settings.outputMany = oldOutputMany;
+ }
+ return '';
+ }
+ Compiler.generateDeclFile = generateDeclFile;
+ var CompilerResult = (function () {
+ function CompilerResult(codeLines, errorLines, scripts) {
+ this.scripts = scripts;
+ this.code = codeLines.join("\n");
+ this.errors = [];
+ for(var i = 0; i < errorLines.length; i++) {
+ var match = errorLines[i].match(/([^\(]*)\((\d+),(\d+)\):\s+((.*[\s\r\n]*.*)+)\s*$/);
+ if(match) {
+ this.errors.push(new CompilerError(match[1], parseFloat(match[2]), parseFloat(match[3]), match[4]));
+ } else {
+ WScript.Echo("non-match on: " + errorLines[i]);
+ }
+ }
+ }
+ CompilerResult.prototype.isErrorAt = function (line, column, message) {
+ for(var i = 0; i < this.errors.length; i++) {
+ if(this.errors[i].line === line && this.errors[i].column === column && this.errors[i].message === message) {
+ return true;
+ }
+ }
+ return false;
+ };
+ return CompilerResult;
+ })();
+ Compiler.CompilerResult = CompilerResult;
+ var CompilerError = (function () {
+ function CompilerError(file, line, column, message) {
+ this.file = file;
+ this.line = line;
+ this.column = column;
+ this.message = message;
+ }
+ CompilerError.prototype.toString = function () {
+ return this.file + "(" + this.line + "," + this.column + "): " + this.message;
+ };
+ return CompilerError;
+ })();
+ Compiler.CompilerError = CompilerError;
+ function recreate() {
+ Compiler.compiler = new TypeScript.TypeScriptCompiler(stderr);
+ Compiler.compiler.parser.errorRecovery = true;
+ Compiler.compiler.settings.codeGenTarget = TypeScript.CodeGenTarget.ES5;
+ Compiler.compiler.settings.controlFlow = true;
+ Compiler.compiler.settings.controlFlowUseDef = true;
+ TypeScript.moduleGenTarget = TypeScript.ModuleGenTarget.Synchronous;
+ Compiler.compiler.addUnit(Compiler.libText, 'lib.d.ts', true);
+ Compiler.compiler.typeCheck();
+ currentUnit = 0;
+ maxUnit = 0;
+ }
+ Compiler.recreate = recreate;
+ function reset() {
+ stdout.reset();
+ stderr.reset();
+ for(var i = 0; i < currentUnit; i++) {
+ Compiler.compiler.updateUnit('', i + '.ts', false);
+ }
+ Compiler.compiler.errorReporter.hasErrors = false;
+ currentUnit = 0;
+ }
+ Compiler.reset = reset;
+ function addUnit(code, isResident, isDeclareFile) {
+ var script = null;
+ if(currentUnit >= maxUnit) {
+ script = Compiler.compiler.addUnit(code, currentUnit++ + (isDeclareFile ? '.d.ts' : '.ts'), isResident);
+ maxUnit++;
+ } else {
+ var filename = currentUnit + (isDeclareFile ? '.d.ts' : '.ts');
+ Compiler.compiler.updateUnit(code, filename, false);
+ for(var i = 0; i < Compiler.compiler.units.length; i++) {
+ if(Compiler.compiler.units[i].filename === filename) {
+ script = Compiler.compiler.scripts.members[i];
+ }
+ }
+ currentUnit++;
+ }
+ return script;
+ }
+ Compiler.addUnit = addUnit;
+ function compileUnit(path, callback, settingsCallback) {
+ if(settingsCallback) {
+ settingsCallback();
+ }
+ path = switchToForwardSlashes(path);
+ compileString(readFile(path), path.match(/[^\/]*$/)[0], callback);
+ }
+ Compiler.compileUnit = compileUnit;
+ function compileUnits(callback, settingsCallback) {
+ reset();
+ if(settingsCallback) {
+ settingsCallback();
+ }
+ Compiler.compiler.reTypeCheck();
+ Compiler.compiler.emitToOutfile(stdout);
+ callback(new CompilerResult(stdout.lines, stderr.lines, []));
+ recreate();
+ reset();
+ }
+ Compiler.compileUnits = compileUnits;
+ function compileString(code, unitName, callback, refreshUnitsForLSTests) {
+ if (typeof refreshUnitsForLSTests === "undefined") { refreshUnitsForLSTests = false; }
+ var scripts = [];
+ if(typeof unitName === 'function') {
+ callback = (unitName);
+ unitName = 'test.ts';
+ }
+ reset();
+ if(refreshUnitsForLSTests) {
+ maxUnit = 0;
+ }
+ scripts.push(addUnit(code));
+ Compiler.compiler.reTypeCheck();
+ Compiler.compiler.emitToOutfile(stdout);
+ callback(new CompilerResult(stdout.lines, stderr.lines, scripts));
+ }
+ Compiler.compileString = compileString;
+ })(CService.Compiler || (CService.Compiler = {}));
+ var Compiler = CService.Compiler;
+ var ScriptInfo = (function () {
+ function ScriptInfo(name, content, isResident, maxScriptVersions) {
+ this.name = name;
+ this.content = content;
+ this.isResident = isResident;
+ this.maxScriptVersions = maxScriptVersions;
+ this.editRanges = [];
+ this.version = 1;
+ }
+ ScriptInfo.prototype.updateContent = function (content, isResident) {
+ this.editRanges = [];
+ this.content = content;
+ this.isResident = isResident;
+ this.version++;
+ };
+ ScriptInfo.prototype.editContent = function (minChar, limChar, newText) {
+ var prefix = this.content.substring(0, minChar);
+ var middle = newText;
+ var suffix = this.content.substring(limChar);
+ this.content = prefix + middle + suffix;
+ this.editRanges.push({
+ length: this.content.length,
+ editRange: new TypeScript.ScriptEditRange(minChar, limChar, (limChar - minChar) + newText.length)
+ });
+ if(this.editRanges.length > this.maxScriptVersions) {
+ this.editRanges.splice(0, this.maxScriptVersions - this.editRanges.length);
+ }
+ this.version++;
+ };
+ ScriptInfo.prototype.getEditRangeSinceVersion = function (version) {
+ if(this.version == version) {
+ return null;
+ }
+ var initialEditRangeIndex = this.editRanges.length - (this.version - version);
+ if(initialEditRangeIndex < 0 || initialEditRangeIndex >= this.editRanges.length) {
+ return TypeScript.ScriptEditRange.unknown();
+ }
+ var entries = this.editRanges.slice(initialEditRangeIndex);
+ var minDistFromStart = entries.map(function (x) {
+ return x.editRange.minChar;
+ }).reduce(function (prev, current) {
+ return Math.min(prev, current);
+ });
+ var minDistFromEnd = entries.map(function (x) {
+ return x.length - x.editRange.limChar;
+ }).reduce(function (prev, current) {
+ return Math.min(prev, current);
+ });
+ var aggDelta = entries.map(function (x) {
+ return x.editRange.delta;
+ }).reduce(function (prev, current) {
+ return prev + current;
+ });
+ return new TypeScript.ScriptEditRange(minDistFromStart, entries[0].length - minDistFromEnd, aggDelta);
+ };
+ return ScriptInfo;
+ })();
+ CService.ScriptInfo = ScriptInfo;
+ var TypeScriptLS = (function () {
+ function TypeScriptLS() {
+ this.ls = null;
+ this.scripts = [];
+ this.maxScriptVersions = 100;
+ }
+ TypeScriptLS.prototype.addDefaultLibrary = function () {
+ this.addScript("lib.d.ts", Compiler.libText, true);
+ };
+ TypeScriptLS.prototype.addFile = function (name, isResident) {
+ if (typeof isResident === "undefined") { isResident = false; }
+ var code = readFile(name);
+ this.addScript(name, code, isResident);
+ };
+ TypeScriptLS.prototype.addScript = function (name, content, isResident) {
+ if (typeof isResident === "undefined") { isResident = false; }
+ var script = new ScriptInfo(name, content, isResident, this.maxScriptVersions);
+ this.scripts.push(script);
+ };
+ TypeScriptLS.prototype.updateScript = function (name, content, isResident) {
+ if (typeof isResident === "undefined") { isResident = false; }
+ for(var i = 0; i < this.scripts.length; i++) {
+ if(this.scripts[i].name == name) {
+ this.scripts[i].updateContent(content, isResident);
+ return;
+ }
+ }
+ this.addScript(name, content, isResident);
+ };
+ TypeScriptLS.prototype.editScript = function (name, minChar, limChar, newText) {
+ for(var i = 0; i < this.scripts.length; i++) {
+ if(this.scripts[i].name == name) {
+ this.scripts[i].editContent(minChar, limChar, newText);
+ return;
+ }
+ }
+ throw new Error("No script with name '" + name + "'");
+ };
+ TypeScriptLS.prototype.getScriptContent = function (scriptIndex) {
+ return this.scripts[scriptIndex].content;
+ };
+ TypeScriptLS.prototype.information = function () {
+ return false;
+ };
+ TypeScriptLS.prototype.debug = function () {
+ return true;
+ };
+ TypeScriptLS.prototype.warning = function () {
+ return true;
+ };
+ TypeScriptLS.prototype.error = function () {
+ return true;
+ };
+ TypeScriptLS.prototype.fatal = function () {
+ return true;
+ };
+ TypeScriptLS.prototype.log = function (s) {
+ };
+ TypeScriptLS.prototype.getCompilationSettings = function () {
+ return "";
+ };
+ TypeScriptLS.prototype.getScriptCount = function () {
+ return this.scripts.length;
+ };
+ TypeScriptLS.prototype.getScriptSourceText = function (scriptIndex, start, end) {
+ return this.scripts[scriptIndex].content.substring(start, end);
+ };
+ TypeScriptLS.prototype.getScriptSourceLength = function (scriptIndex) {
+ return this.scripts[scriptIndex].content.length;
+ };
+ TypeScriptLS.prototype.getScriptId = function (scriptIndex) {
+ return this.scripts[scriptIndex].name;
+ };
+ TypeScriptLS.prototype.getScriptIsResident = function (scriptIndex) {
+ return this.scripts[scriptIndex].isResident;
+ };
+ TypeScriptLS.prototype.getScriptVersion = function (scriptIndex) {
+ return this.scripts[scriptIndex].version;
+ };
+ TypeScriptLS.prototype.getScriptEditRangeSinceVersion = function (scriptIndex, scriptVersion) {
+ var range = this.scripts[scriptIndex].getEditRangeSinceVersion(scriptVersion);
+ var result = (range.minChar + "," + range.limChar + "," + range.delta);
+ return result;
+ };
+ TypeScriptLS.prototype.getLanguageService = function () {
+ var ls = new Services.TypeScriptServicesFactory().createLanguageServiceShim(this);
+ ls.refresh(true);
+ this.ls = ls;
+ return ls;
+ };
+ TypeScriptLS.prototype.parseSourceText = function (fileName, sourceText) {
+ var parser = new TypeScript.Parser();
+ parser.setErrorRecovery(null);
+ parser.errorCallback = function (a, b, c, d) {
+ };
+ var script = parser.parse(sourceText, fileName, 0);
+ return script;
+ };
+ TypeScriptLS.prototype.parseFile = function (fileName) {
+ var sourceText = new TypeScript.StringSourceText(IO.readFile(fileName));
+ return this.parseSourceText(fileName, sourceText);
+ };
+ TypeScriptLS.prototype.lineColToPosition = function (fileName, line, col) {
+ var script = this.ls.languageService.getScriptAST(fileName);
+ return TypeScript.getPositionFromLineColumn(script, line, col);
+ };
+ TypeScriptLS.prototype.positionToLineCol = function (fileName, position) {
+ var script = this.ls.languageService.getScriptAST(fileName);
+ var result = TypeScript.getLineColumnFromPosition(script, position);
+ return result;
+ };
+ TypeScriptLS.prototype.checkEdits = function (sourceFileName, baselineFileName, edits) {
+ var script = readFile(sourceFileName);
+ var formattedScript = this.applyEdits(script, edits);
+ var baseline = readFile(baselineFileName);
+ };
+ TypeScriptLS.prototype.applyEdits = function (content, edits) {
+ var result = content;
+ edits = this.normalizeEdits(edits);
+ for(var i = edits.length - 1; i >= 0; i--) {
+ var edit = edits[i];
+ var prefix = result.substring(0, edit.minChar);
+ var middle = edit.text;
+ var suffix = result.substring(edit.limChar);
+ result = prefix + middle + suffix;
+ }
+ return result;
+ };
+ TypeScriptLS.prototype.normalizeEdits = function (edits) {
+ var result = [];
+ function mapEdits(edits) {
+ var result = [];
+ for(var i = 0; i < edits.length; i++) {
+ result.push({
+ edit: edits[i],
+ index: i
+ });
+ }
+ return result;
+ }
+ var temp = mapEdits(edits).sort(function (a, b) {
+ var result = a.edit.minChar - b.edit.minChar;
+ if(result == 0) {
+ result = a.index - b.index;
+ }
+ return result;
+ });
+ var current = 0;
+ var next = 1;
+ while(current < temp.length) {
+ var currentEdit = temp[current].edit;
+ if(next >= temp.length) {
+ result.push(currentEdit);
+ current++;
+ continue;
+ }
+ var nextEdit = temp[next].edit;
+ var gap = nextEdit.minChar - currentEdit.limChar;
+ if(gap >= 0) {
+ result.push(currentEdit);
+ current = next;
+ next++;
+ continue;
+ }
+ if(currentEdit.limChar >= nextEdit.limChar) {
+ next++;
+ continue;
+ } else {
+ throw new Error("Trying to apply overlapping edits");
+ }
+ }
+ return result;
+ };
+ return TypeScriptLS;
+ })();
+ CService.TypeScriptLS = TypeScriptLS;
+})(CService || (CService = {}));
+var readline = require('readline');
+var ts_ls = new CService.TypeScriptLS();
+var ls;
+function lineColToPosition(fileName, line, col) {
+ var script = ls.languageService.getScriptAST(fileName);
+ var lineMap = script.locationInfo.lineMap;
+ var offset = lineMap[line] + (col - 1);
+ return offset;
+}
+function repl(prompt, callback) {
+ var rl = readline.createInterface(process.stdin, process.stdout);
+ rl.setPrompt(prompt);
+ rl.prompt();
+ rl.on('line', function (line) {
+ callback(line);
+ rl.prompt();
+ });
+}
+var repl_actions = {
+ "set_root": function (root_path) {
+ CService.userSpecifiedroot = root_path;
+ return {
+ status: "OK"
+ };
+ },
+ "add_file": function (file_path) {
+ ts_ls.addFile(file_path);
+ ls = ts_ls.getLanguageService();
+ return {
+ status: "OK"
+ };
+ },
+ "complete": function (file_path, pos, is_member) {
+ var ipos = (pos instanceof Array) ? lineColToPosition(file_path, pos[0], pos[1]) : pos;
+ return {
+ status: "OK",
+ result: ls.languageService.getCompletionsAtPosition(file_path, ipos, is_member)
+ };
+ },
+ "edit_script": function (file_path, min_char, lim_char, new_text) {
+ ts_ls.editScript(file_path, min_char, lim_char, new_text);
+ return {
+ status: "OK"
+ };
+ },
+ "update_script": function (file_path, content) {
+ ts_ls.updateScript(file_path, content);
+ return {
+ status: "OK"
+ };
+ },
+ "get_errors": function (file_path) {
+ return {
+ status: "OK",
+ result: ls.languageService.getScriptErrors(file_path, 100)
+ };
+ },
+ "dummy": function () {
+ return {
+ status: "OK",
+ data: "dummy"
+ };
+ }
+};
+repl("", function (line) {
+ var json_data = JSON.parse(line);
+ var result;
+ try {
+ result = repl_actions[json_data[0]].apply(null, json_data.slice(1));
+ console.error(result);
+ } catch (err) {
+ console.error(err);
+ result = {
+ status: "ERROR",
+ error: err
+ };
+ }
+ console.log(JSON.stringify(result));
+});
diff --git a/bin/typescript.js b/bin/typescript.js
new file mode 100644
index 0000000..a771563
--- /dev/null
+++ b/bin/typescript.js
@@ -0,0 +1,23710 @@
+/* *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+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.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 = 0x27d4eb2d;
+ 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, text) {
+ _super.call(this, TypeScript.NodeType.NumberLit);
+ this.value = value;
+ this.text = text;
+ }
+ 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);
+ emitter.writeToOutput(this.text);
+ emitter.recordSourceMappingEnd(this);
+ emitter.emitParensAndCommentsInPlace(this, false);
+ };
+ NumberLiteral.prototype.printLabel = function () {
+ return this.text;
+ };
+ return NumberLiteral;
+ })(Expression);
+ TypeScript.NumberLiteral = NumberLiteral;
+ var RegexLiteral = (function (_super) {
+ __extends(RegexLiteral, _super);
+ function RegexLiteral(text) {
+ _super.call(this, TypeScript.NodeType.Regex);
+ this.text = text;
+ }
+ 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.text);
+ 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.isInlineCallLiteral = false;
+ this.accessorSymbol = null;
+ this.leftCurlyCount = 0;
+ this.rightCurlyCount = 0;
+ this.returnStatementsWithExpressions = [];
+ this.scopeType = null;
+ this.endingToken = null;
+ this.constructorSpan = 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;
+ }
+ 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) {
+ if(this.bod.members.length == 0) {
+ return this.setCachedEmitRequired(true);
+ }
+ 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.emitJavascriptList(this.bod, null, TypeScript.TokenID.Semicolon, true, false, false, true, this.requiresExtendsBlock);
+ }
+ };
+ 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, 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.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.isWholeFile = function () {
+ return TypeScript.hasFlag(this.modFlags, TypeScript.ModuleFlags.IsWholeFile);
+ };
+ 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.emitJavascriptModule(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;
+ this.colonSpan = new ASTSpan();
+ }
+ 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.recordSourceMappingStart(this.colonSpan);
+ emitter.writeToOutput(":");
+ emitter.recordSourceMappingEnd(this.colonSpan);
+ 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) == "*" && this.content.charAt(3) != "/";
+ }
+ 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.getDocCommentFirstOverloadSignature = function getDocCommentFirstOverloadSignature(signatureGroup) {
+ for(var i = 0; i < signatureGroup.signatures.length; i++) {
+ var signature = signatureGroup.signatures[i];
+ if(signature == signatureGroup.definitionSignature) {
+ continue;
+ }
+ return TypeScript.Comment.getDocCommentText(signature.declAST.getDocComments());
+ }
+ return "";
+ };
+ 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.writeToOutput("debugger");
+ emitter.recordSourceMappingEnd(this);
+ emitter.writeLineToOutput(";");
+ 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 && (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 && (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);
+ }
+ var callAndConstructScope = scope;
+ 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);
+ }
+ if(type.isModuleType()) {
+ callAndConstructScope = agg;
+ }
+ this.checker.currentModDecl = prevCurrentModDecl;
+ this.checker.inBind = prevBindStatus;
+ }
+ if(type.extendsTypeLinks) {
+ this.resolveBases(scope, type);
+ }
+ if(type.construct) {
+ this.resolveSignatureGroup(type.construct, callAndConstructScope, instanceType);
+ }
+ if(type.call) {
+ this.resolveSignatureGroup(type.call, callAndConstructScope, 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 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
+ });
+ };
+ }
+})());
+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, emitFullPathOfSourceMap) {
+ 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);
+ if(emitFullPathOfSourceMap) {
+ if(jsFileName.indexOf("://") == -1) {
+ jsFileName = "file:///" + jsFileName;
+ }
+ this.jsFileName = jsFileName;
+ }
+ 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;
+ }
+ 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;
+ this.emitFullSourceMapPath = settings.emitFullSourceMapPath;
+ }
+ 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.globalThisCapturePrologueEmitted = false;
+ this.extendsPrologueEmitted = 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) {
+ var text = comment.getText();
+ var hadNewLine = false;
+ if(comment.isBlockComment) {
+ if(this.emitState.column == 0) {
+ this.emitIndent();
+ }
+ this.recordSourceMappingStart(comment);
+ this.writeToOutput(text[0]);
+ if(text.length > 1 || comment.endsLine) {
+ for(var i = 1; i < text.length; i++) {
+ this.writeLineToOutput("");
+ this.emitIndent();
+ this.writeToOutput(text[i]);
+ }
+ this.recordSourceMappingEnd(comment);
+ this.writeLineToOutput("");
+ hadNewLine = true;
+ } else {
+ this.recordSourceMappingEnd(comment);
+ }
+ } else {
+ if(this.emitState.column == 0) {
+ this.emitIndent();
+ }
+ this.recordSourceMappingStart(comment);
+ this.writeToOutput(text[0]);
+ this.recordSourceMappingEnd(comment);
+ this.writeLineToOutput("");
+ hadNewLine = true;
+ }
+ if(hadNewLine) {
+ this.emitIndent();
+ } else {
+ this.writeToOutput(" ");
+ }
+ };
+ 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.getConstantValue = function (init) {
+ if(init) {
+ if(init.nodeType === TypeScript.NodeType.NumberLit) {
+ var numLit = init;
+ return numLit.value;
+ } else if(init.nodeType === TypeScript.NodeType.Lsh) {
+ var binop = init;
+ if(binop.operand1.nodeType === TypeScript.NodeType.NumberLit && binop.operand2.nodeType === TypeScript.NodeType.NumberLit) {
+ return (binop.operand1).value << (binop.operand2).value;
+ }
+ } else if(init.nodeType === TypeScript.NodeType.Name) {
+ var ident = init;
+ if(ident.sym !== null && ident.sym.declAST.nodeType === TypeScript.NodeType.VarDecl) {
+ var varDecl = ident.sym.declAST;
+ return this.getConstantValue(varDecl.init);
+ }
+ }
+ }
+ return null;
+ };
+ 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;
+ var value = this.getConstantValue(boundDecl.init);
+ if(value !== null) {
+ this.writeToOutput(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.Signature) || 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.emitOptions.emitFullSourceMapPath));
+ 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.writeToOutput(")(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.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));");
+ } else if(!isExported && temp != EmitContainer.Prog) {
+ this.writeToOutput("}");
+ if(!isWholeFile) {
+ this.recordSourceMappingNameEnd();
+ }
+ this.recordSourceMappingEnd(moduleDecl.endingToken);
+ this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));");
+ } else {
+ this.writeToOutput("}");
+ if(!isWholeFile) {
+ this.recordSourceMappingNameEnd();
+ }
+ this.recordSourceMappingEnd(moduleDecl.endingToken);
+ this.writeToOutput(")();");
+ }
+ this.recordSourceMappingEnd(moduleDecl);
+ this.writeLineToOutput("");
+ 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.Signature)) {
+ 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 isSingleQuotedMod = TypeScript.isSingleQuoted(modPath);
+ 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);
+ if(isSingleQuotedMod) {
+ modPath = TypeScript.changeToSingleQuote(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[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;
+ this.emitParensAndCommentsInPlace(ast, true);
+ if(list.members.length == 0) {
+ this.emitParensAndCommentsInPlace(ast, false);
+ return;
+ }
+ 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.extendsPrologueEmitted) {
+ if(reqInherits) {
+ this.extendsPrologueEmitted = 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.globalThisCapturePrologueEmitted) {
+ if(this.checker.mustCaptureGlobalThis) {
+ this.globalThisCapturePrologueEmitted = 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;
+ 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.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;
+ var memberNames = [];
+ 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;
+ memberNames.push(memberName);
+ } 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, "0");
+ lastValue = memberValue;
+ } else {
+ var nextValue = lastValue.value + 1;
+ memberValue = new TypeScript.NumberLiteral(nextValue, nextValue.toString());
+ 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;
+ } else if(memberValue.nodeType === TypeScript.NodeType.Lsh) {
+ var binop = memberValue;
+ if(binop.operand1.nodeType === TypeScript.NodeType.NumberLit && binop.operand2.nodeType === TypeScript.NodeType.NumberLit) {
+ member.varFlags |= TypeScript.VarFlags.Constant;
+ }
+ } else if(memberValue.nodeType === TypeScript.NodeType.Name) {
+ var nameNode = memberValue;
+ for(var i = 0; i < memberNames.length; i++) {
+ var memberName = memberNames[i];
+ if(memberName.text === nameNode.text) {
+ member.varFlags |= TypeScript.VarFlags.Constant;
+ break;
+ }
+ }
+ }
+ 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(), 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(), 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(), 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(), endingToken);
+ } else {
+ moduleDecl = new TypeScript.ModuleDeclaration(name, moduleBody, this.topVarList(), 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.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;
+ if(bod.limChar > bod.minChar) {
+ 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.limChar = retExpr.limChar;
+ bod.append(retStmt);
+ } else if(this.currentToken.tokenId != TypeScript.TokenID.EndOfFile) {
+ 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.Signature;
+ }
+ 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;
+ opArg.isParenthesized = false;
+ 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);
+ formals.minChar = preProcessedLambdaArgs.minChar;
+ 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.currentToken.tokenId == TypeScript.TokenID.EndOfFile ? this.scanner.pos : 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 && !methodName) {
+ this.currentToken = this.scanner.scan();
+ 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;
+ }
+ }
+ 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);
+ }
+ 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");
+ }
+ if(isLambda && this.currentToken.tokenId != TypeScript.TokenID.EqualsGreaterThan) {
+ this.reportParseError("Expected '=>'");
+ }
+ if(isDecl && !(this.parsingDeclareFile || markedAsAmbient) && !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(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 > 0xffff) {
+ 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(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();
+ var constructorSpan = new TypeScript.ASTSpan();
+ constructorSpan.minChar = this.scanner.startPos;
+ constructorSpan.limChar = this.scanner.pos;
+ 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.constructorSpan = constructorSpan;
+ 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, unnamedAmbientFunctionOk) {
+ 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;
+ }
+ if(!text && unnamedAmbientFunctionOk && !isIndexer) {
+ text = new TypeScript.MissingIdentifier();
+ }
+ var ast = this.parseFncDecl(ers, true, requireSignature, this.currentClassDefinition || this.inInterfaceDecl, 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 || (text.isMissing() && unnamedAmbientFunctionOk && !isIndexer)) {
+ 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:
+ 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.currentToken.tokenId == TypeScript.TokenID.EndOfFile ? this.scanner.pos : 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.currentToken.tokenId == TypeScript.TokenID.EndOfFile ? this.scanner.pos : 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.text);
+ 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.text);
+ 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);
+ 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());
+ if(preComments) {
+ ast.preComments = ast.preComments ? preComments.concat(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.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();
+ 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, true);
+ 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(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported) || 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, false, 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);
+ 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;
+ break;
+ default:
+ temp = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon | TypeScript.ErrorRecoverySet.In, TypeScript.OperatorPrecedence.None, false, TypeContext.NoTypes);
+ break;
+ }
+ 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);
+ }
+ caseStmt.colonSpan.minChar = this.scanner.startPos;
+ caseStmt.colonSpan.limChar = this.scanner.pos;
+ 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 = ast.preComments ? preComments.concat(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).bod == null));
+ };
+ 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;
+ 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)) {
+ 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.fname = filename;
+ this.currentUnitIndex = unitIndex;
+ this.currentToken = null;
+ this.needTerminator = false;
+ this.inFunction = false;
+ this.inInterfaceDecl = false;
+ this.inFncDecl = false;
+ this.ambientModule = false;
+ this.ambientClass = false;
+ this.topLevel = true;
+ this.allowImportDeclaration = true;
+ 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.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.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();
+ }
+ 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(), 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 = 0x0A;
+ TypeScript.LexCodeRET = 0x0D;
+ TypeScript.LexCodeLS = 0x2028;
+ TypeScript.LexCodePS = 0x2029;
+ TypeScript.LexCodeTAB = 0x09;
+ TypeScript.LexCodeVTAB = 0x0B;
+ 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,
+ 19893,
+ 19968,
+ 40869,
+ 40960,
+ 42124,
+ 44032,
+ 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,
+ 19893,
+ 19968,
+ 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,
+ 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.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.lastTokenLimChar = function () {
+ if(this.prevSavedToken !== null) {
+ return this.prevSavedToken.limChar;
+ } else {
+ return 0;
+ }
+ };
+ SavedTokens.prototype.lastTokenHadNewline = function () {
+ return this.prevLine != this.startLine;
+ };
+ 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.setText = function (newSrc, textMode) {
+ this.setSourceText(new StringSourceText(newSrc), textMode);
+ };
+ Scanner.prototype.setScanComments = function (value) {
+ this.scanComments = value;
+ };
+ 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseInt(text), text);
+ } else {
+ return null;
+ }
+ }
+ }
+ };
+ Scanner.prototype.scanOctalDigits = function () {
+ var atLeastOneDigit = false;
+ for(; ; ) {
+ if(this.IsOctalDigit(this.ch)) {
+ this.nextChar();
+ atLeastOneDigit = true;
+ } else {
+ if(atLeastOneDigit) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseInt(text), text);
+ } 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ } 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ } 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ } else {
+ if(!atLeastOneDigit) {
+ this.pos = svPos;
+ this.col = svCol;
+ return null;
+ } else {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ }
+ }
+ } else {
+ if(!atLeastOneDigit) {
+ this.pos = svPos;
+ this.col = svCol;
+ return null;
+ } else {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ }
+ }
+ }
+ };
+ 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.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(this.src.substring(svPos - 1, this.pos));
+ }
+ }
+ 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 = this.peekChar();
+ this.lexState = LexState.Start;
+ return this.scanStringConstant(TypeScript.LexCodeAPO);
+ } else if(this.lexState == LexState.InMultilineDoubleQuoteString && this.pos < this.len) {
+ this.ch = this.peekChar();
+ this.lexState = LexState.Start;
+ return this.scanStringConstant(TypeScript.LexCodeQUO);
+ }
+ 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 (endCode) {
+ 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.newLine();
+ if(this.mode == LexMode.Line) {
+ this.nextChar();
+ 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)) {
+ var endCode = this.ch;
+ this.nextChar();
+ return this.scanStringConstant(endCode);
+ } 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 0xFF:
+ case 0xFE:
+ case 0xEF:
+ case 0xBB:
+ case 0xBF:
+ 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) && !funcDecl.isAccessor()) {
+ 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);
+ } 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.Signature)) {
+ this.definitionSignature = signature;
+ }
+ };
+ SignatureGroup.prototype.toString = function () {
+ return this.signatures.toString();
+ };
+ SignatureGroup.prototype.toStrings = function (prefix, shortform, scope, getPrettyTypeName, useSignature) {
+ var _this = this;
+ var result = [];
+ var len = this.signatures.length;
+ if(!getPrettyTypeName && len > 1) {
+ shortform = false;
+ }
+ var getMemberNameOfSignature = function (signature) {
+ if(_this.flags & TypeScript.SignatureFlags.IsIndexer) {
+ return signature.toStringHelperEx(shortform, true, scope);
+ } else {
+ return signature.toStringHelperEx(shortform, false, scope, prefix);
+ }
+ };
+ if(useSignature) {
+ result.push(getMemberNameOfSignature(useSignature));
+ } else {
+ for(var i = 0; i < len; i++) {
+ if(len > 1 && this.signatures[i] == this.definitionSignature) {
+ continue;
+ }
+ result.push(getMemberNameOfSignature(this.signatures[i]));
+ if(getPrettyTypeName) {
+ break;
+ }
+ }
+ }
+ if(getPrettyTypeName && len > 1) {
+ var lastMemberName = result[result.length - 1];
+ var overloadString = " (+ " + ((this.definitionSignature != null) ? len - 2 : len - 1) + " overload(s))";
+ lastMemberName.add(TypeScript.MemberName.create(overloadString));
+ }
+ 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.Signature) && TypeScript.hasFlag(this.signatures[j].declAST.fncFlags, TypeScript.FncFlags.Signature)) && 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 (scope) {
+ var scopeSymbol = !scope ? null : scope.container;
+ var scopeRootPath = !scopeSymbol ? [] : scopeSymbol.pathToRoot();
+ var dynamicModuleRoot = null;
+ if(scopeRootPath.length > 0 && scopeRootPath[scopeRootPath.length - 1].declAST && scopeRootPath[scopeRootPath.length - 1].declAST.nodeType == TypeScript.NodeType.ModuleDeclaration && (scopeRootPath[scopeRootPath.length - 1].declAST).isWholeFile()) {
+ dynamicModuleRoot = scopeRootPath[scopeRootPath.length - 1];
+ }
+ var builder = this.getPrettyName(scopeSymbol);
+ var ancestor = this.container;
+ while(ancestor && (ancestor.name != TypeScript.globalId) && ancestor != dynamicModuleRoot) {
+ builder = ancestor.getPrettyName(scopeSymbol) + "." + 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 ? this.field.typeLink.type.getScopedTypeNameEx(scope) : TypeScript.MemberName.create("any"), 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;
+ };
+ ParameterSymbol.prototype.fullName = function () {
+ return this.name;
+ };
+ return ParameterSymbol;
+ })(InferenceSymbol);
+ TypeScript.ParameterSymbol = ParameterSymbol;
+ var VariableSymbol = (function (_super) {
+ __extends(VariableSymbol, _super);
+ function VariableSymbol(name, location, unitIndex, variable) {
+ _super.call(this, name, location, name.length, unitIndex);
+ this.variable = variable;
+ }
+ VariableSymbol.prototype.kind = function () {
+ return TypeScript.SymbolKind.Variable;
+ };
+ VariableSymbol.prototype.writeable = function () {
+ return true;
+ };
+ VariableSymbol.prototype.getType = function () {
+ return this.variable.typeLink.type;
+ };
+ VariableSymbol.prototype.getTypeNameEx = function (scope) {
+ return TypeScript.MemberName.create(this.getType().getScopedTypeNameEx(scope), this.name + ": ", "");
+ };
+ VariableSymbol.prototype.setType = function (type) {
+ this.variable.typeLink.type = type;
+ };
+ VariableSymbol.prototype.isVariable = function () {
+ return true;
+ };
+ return VariableSymbol;
+ })(InferenceSymbol);
+ TypeScript.VariableSymbol = VariableSymbol;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+ var ScopedMembers = (function () {
+ function ScopedMembers(dualMembers) {
+ this.dualMembers = dualMembers;
+ this.allMembers = this.dualMembers;
+ this.publicMembers = this.dualMembers.primaryTable;
+ this.privateMembers = this.dualMembers.secondaryTable;
+ }
+ ScopedMembers.prototype.addPublicMember = function (key, data) {
+ return this.dualMembers.primaryTable.add(key, data);
+ };
+ ScopedMembers.prototype.addPrivateMember = function (key, data) {
+ return this.dualMembers.secondaryTable.add(key, data);
+ };
+ return ScopedMembers;
+ })();
+ TypeScript.ScopedMembers = ScopedMembers;
+ (function (SymbolKind) {
+ SymbolKind._map = [];
+ SymbolKind._map[0] = "None";
+ SymbolKind.None = 0;
+ SymbolKind._map[1] = "Type";
+ SymbolKind.Type = 1;
+ SymbolKind._map[2] = "Field";
+ SymbolKind.Field = 2;
+ SymbolKind._map[3] = "Parameter";
+ SymbolKind.Parameter = 3;
+ SymbolKind._map[4] = "Variable";
+ SymbolKind.Variable = 4;
+ })(TypeScript.SymbolKind || (TypeScript.SymbolKind = {}));
+ var SymbolKind = TypeScript.SymbolKind;
+ var SymbolScope = (function () {
+ function SymbolScope(container) {
+ this.container = container;
+ }
+ SymbolScope.prototype.printLabel = function () {
+ return "base";
+ };
+ SymbolScope.prototype.getAllSymbolNames = function (members) {
+ return [
+ "please",
+ "implement",
+ "in",
+ "derived",
+ "classes"
+ ];
+ };
+ SymbolScope.prototype.getAllTypeSymbolNames = function (members) {
+ return [
+ "please",
+ "implement",
+ "in",
+ "derived",
+ "classes"
+ ];
+ };
+ SymbolScope.prototype.getAllValueSymbolNames = function (members) {
+ return [
+ "please",
+ "implement",
+ "in",
+ "derived",
+ "classes"
+ ];
+ };
+ SymbolScope.prototype.search = function (filter, name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.findLocal = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.find = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.findImplementation = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.findAmbient = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.print = function (outfile) {
+ if(this.container) {
+ outfile.WriteLine(this.printLabel() + " scope with container: " + this.container.name + "...");
+ } else {
+ outfile.WriteLine(this.printLabel() + " scope...");
+ }
+ };
+ SymbolScope.prototype.enter = function (container, ast, symbol, errorReporter, publicOnly, typespace, ambient) {
+ throw new Error("please implement in derived class");
+ };
+ SymbolScope.prototype.getTable = function () {
+ throw new Error("please implement in derived class");
+ };
+ return SymbolScope;
+ })();
+ TypeScript.SymbolScope = SymbolScope;
+ function symbolCanBeUsed(sym, publicOnly) {
+ return publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true;
+ }
+ var SymbolAggregateScope = (function (_super) {
+ __extends(SymbolAggregateScope, _super);
+ function SymbolAggregateScope(container) {
+ _super.call(this, container);
+ this.valueCache = null;
+ this.valueImplCache = null;
+ this.valueAmbientCache = null;
+ this.typeCache = null;
+ this.typeImplCache = null;
+ this.typeAmbientCache = null;
+ this.parents = null;
+ this.container = container;
+ }
+ SymbolAggregateScope.prototype.printLabel = function () {
+ return "agg";
+ };
+ SymbolAggregateScope.prototype.search = function (filter, name, publicOnly, typespace) {
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var sym = this.parents[i].search(filter, name, publicOnly, typespace);
+ if(sym) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ }
+ return filter.result;
+ };
+ SymbolAggregateScope.prototype.getAllSymbolNames = function (members) {
+ var result = [];
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var parentResult = this.parents[i].getAllSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ }
+ return result;
+ };
+ SymbolAggregateScope.prototype.getAllTypeSymbolNames = function (members) {
+ var result = [];
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var parentResult = this.parents[i].getAllTypeSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ }
+ return result;
+ };
+ SymbolAggregateScope.prototype.getAllValueSymbolNames = function (members) {
+ var result = [];
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var parentResult = this.parents[i].getAllValueSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ }
+ return result;
+ };
+ SymbolAggregateScope.prototype.print = function (outfile) {
+ _super.prototype.print.call(this, outfile);
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ this.parents[i].print(outfile);
+ }
+ }
+ };
+ SymbolAggregateScope.prototype.findImplementation = function (name, publicOnly, typespace) {
+ var sym = null;
+ var i = 0;
+ var implCache = this.valueImplCache;
+ if(typespace) {
+ implCache = this.typeImplCache;
+ }
+ if(implCache && ((sym = implCache.lookup(name)) != null) && (publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true)) {
+ return sym;
+ }
+ if(this.parents) {
+ for(i = 0; i < this.parents.length; i++) {
+ sym = this.parents[i].findImplementation(name, publicOnly, typespace);
+ if(sym) {
+ break;
+ }
+ }
+ }
+ if(implCache) {
+ if(typespace) {
+ this.typeImplCache = new TypeScript.StringHashTable();
+ implCache = this.typeImplCache;
+ } else {
+ this.valueImplCache = new TypeScript.StringHashTable();
+ implCache = this.valueImplCache;
+ }
+ }
+ implCache.add(name, sym);
+ return sym;
+ };
+ SymbolAggregateScope.prototype.find = function (name, publicOnly, typespace) {
+ var sym = null;
+ var i = 0;
+ var cache = this.valueCache;
+ if(typespace) {
+ cache = this.typeCache;
+ }
+ if(cache && ((sym = cache.lookup(name)) != null) && (publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true)) {
+ return sym;
+ }
+ if(this.parents) {
+ for(i = 0; i < this.parents.length; i++) {
+ sym = this.parents[i].find(name, publicOnly, typespace);
+ if(sym) {
+ break;
+ }
+ }
+ }
+ if(cache == null) {
+ if(typespace) {
+ this.typeCache = new TypeScript.StringHashTable();
+ cache = this.typeCache;
+ } else {
+ this.valueCache = new TypeScript.StringHashTable();
+ cache = this.valueCache;
+ }
+ }
+ cache.add(name, sym);
+ return sym;
+ };
+ SymbolAggregateScope.prototype.findAmbient = function (name, publicOnly, typespace) {
+ var sym = null;
+ var i = 0;
+ var cache = this.valueAmbientCache;
+ if(typespace) {
+ cache = this.typeAmbientCache;
+ }
+ if(cache && ((sym = cache.lookup(name)) != null)) {
+ return sym;
+ }
+ if(this.parents) {
+ for(i = 0; i < this.parents.length; i++) {
+ sym = this.parents[i].findAmbient(name, publicOnly, typespace);
+ if(sym) {
+ break;
+ }
+ }
+ }
+ if(cache == null) {
+ if(typespace) {
+ this.typeAmbientCache = new TypeScript.StringHashTable();
+ cache = this.typeAmbientCache;
+ } else {
+ this.valueAmbientCache = new TypeScript.StringHashTable();
+ cache = this.valueAmbientCache;
+ }
+ }
+ cache.add(name, sym);
+ return sym;
+ };
+ SymbolAggregateScope.prototype.addParentScope = function (parent) {
+ if(this.parents == null) {
+ this.parents = new Array();
+ }
+ this.parents[this.parents.length] = parent;
+ };
+ return SymbolAggregateScope;
+ })(SymbolScope);
+ TypeScript.SymbolAggregateScope = SymbolAggregateScope;
+ var SymbolTableScope = (function (_super) {
+ __extends(SymbolTableScope, _super);
+ function SymbolTableScope(valueMembers, ambientValueMembers, enclosedTypes, ambientEnclosedTypes, container) {
+ _super.call(this, container);
+ this.valueMembers = valueMembers;
+ this.ambientValueMembers = ambientValueMembers;
+ this.enclosedTypes = enclosedTypes;
+ this.ambientEnclosedTypes = ambientEnclosedTypes;
+ this.container = container;
+ }
+ SymbolTableScope.prototype.printLabel = function () {
+ return "table";
+ };
+ SymbolTableScope.prototype.getAllSymbolNames = function (members) {
+ var result = this.getAllTypeSymbolNames(members);
+ return result.concat(this.getAllValueSymbolNames(members));
+ };
+ SymbolTableScope.prototype.getAllTypeSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientEnclosedTypes) {
+ result = result.concat(this.ambientEnclosedTypes.allMembers.getAllKeys());
+ }
+ if(this.enclosedTypes) {
+ result = result.concat(this.enclosedTypes.allMembers.getAllKeys());
+ }
+ return result;
+ };
+ SymbolTableScope.prototype.getAllValueSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientValueMembers) {
+ result = result.concat(this.ambientValueMembers.allMembers.getAllKeys());
+ }
+ if(this.valueMembers) {
+ result = result.concat(this.valueMembers.allMembers.getAllKeys());
+ }
+ return result;
+ };
+ SymbolTableScope.prototype.search = function (filter, name, publicOnly, typespace) {
+ var sym = this.find(name, publicOnly, typespace);
+ filter.update(sym);
+ return filter.result;
+ };
+ SymbolTableScope.prototype.find = function (name, publicOnly, typespace) {
+ var table = null;
+ var ambientTable = null;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ } else {
+ table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ }
+ if(ambientTable) {
+ var s = ambientTable.lookup(name);
+ if(s) {
+ return s;
+ }
+ }
+ if(table) {
+ var s = table.lookup(name);
+ if(s) {
+ return s;
+ }
+ }
+ return null;
+ };
+ SymbolTableScope.prototype.findAmbient = function (name, publicOnly, typespace) {
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable) {
+ var s = ambientTable.lookup(name);
+ if(s) {
+ return s;
+ }
+ }
+ return null;
+ };
+ SymbolTableScope.prototype.print = function (outfile) {
+ _super.prototype.print.call(this, outfile);
+ if(this.ambientValueMembers) {
+ this.ambientValueMembers.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.valueMembers) {
+ this.valueMembers.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.ambientEnclosedTypes) {
+ this.ambientEnclosedTypes.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.enclosedTypes) {
+ this.enclosedTypes.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ };
+ SymbolTableScope.prototype.findImplementation = function (name, publicOnly, typespace) {
+ var sym = this.find(name, publicOnly, typespace);
+ if(sym) {
+ if(sym.kind() == SymbolKind.Type) {
+ var typeSym = sym;
+ if(!typeSym.type.hasImplementation()) {
+ sym = null;
+ }
+ } else if(sym.container) {
+ if(sym.container.kind() == SymbolKind.Type) {
+ var ctypeSym = sym.container;
+ if(!ctypeSym.type.hasImplementation()) {
+ sym = null;
+ }
+ }
+ }
+ }
+ return sym;
+ };
+ SymbolTableScope.prototype.getTable = function () {
+ return this.valueMembers.publicMembers;
+ };
+ return SymbolTableScope;
+ })(SymbolScope);
+ TypeScript.SymbolTableScope = SymbolTableScope;
+ var SymbolScopeBuilder = (function (_super) {
+ __extends(SymbolScopeBuilder, _super);
+ function SymbolScopeBuilder(valueMembers, ambientValueMembers, enclosedTypes, ambientEnclosedTypes, parent, container) {
+ _super.call(this, container);
+ this.valueMembers = valueMembers;
+ this.ambientValueMembers = ambientValueMembers;
+ this.enclosedTypes = enclosedTypes;
+ this.ambientEnclosedTypes = ambientEnclosedTypes;
+ this.parent = parent;
+ this.container = container;
+ }
+ SymbolScopeBuilder.prototype.printLabel = function () {
+ return "builder";
+ };
+ SymbolScopeBuilder.prototype.getAllSymbolNames = function (members) {
+ var result = this.getAllTypeSymbolNames(members);
+ return result.concat(this.getAllValueSymbolNames(members));
+ };
+ SymbolScopeBuilder.prototype.getAllTypeSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientEnclosedTypes) {
+ result = result.concat(this.ambientEnclosedTypes.allMembers.getAllKeys());
+ }
+ if(this.enclosedTypes) {
+ result = result.concat(this.enclosedTypes.allMembers.getAllKeys());
+ }
+ if(!members && this.parent) {
+ var parentResult = this.parent.getAllTypeSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ return result;
+ };
+ SymbolScopeBuilder.prototype.getAllValueSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientValueMembers) {
+ result = result.concat(this.ambientValueMembers.allMembers.getAllKeys());
+ }
+ if(this.valueMembers) {
+ result = result.concat(this.valueMembers.allMembers.getAllKeys());
+ }
+ if(!members && this.parent) {
+ var parentResult = this.parent.getAllValueSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ return result;
+ };
+ SymbolScopeBuilder.prototype.search = function (filter, name, publicOnly, typespace) {
+ var sym = null;
+ var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable) {
+ if((sym = ambientTable.lookup(name)) != null) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ if(table) {
+ if((sym = table.lookup(name)) != null) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ if(this.parent) {
+ sym = this.parent.search(filter, name, publicOnly, typespace);
+ if(sym) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ return filter.result;
+ };
+ SymbolScopeBuilder.prototype.print = function (outfile) {
+ _super.prototype.print.call(this, outfile);
+ if(this.ambientValueMembers) {
+ this.ambientValueMembers.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.valueMembers) {
+ this.valueMembers.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.ambientEnclosedTypes) {
+ this.ambientEnclosedTypes.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.enclosedTypes) {
+ this.enclosedTypes.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.parent) {
+ this.parent.print(outfile);
+ }
+ };
+ SymbolScopeBuilder.prototype.find = function (name, publicOnly, typespace) {
+ var sym = null;
+ var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable && ((sym = ambientTable.lookup(name)) != null)) {
+ return sym;
+ }
+ if(table && ((sym = table.lookup(name)) != null)) {
+ return sym;
+ }
+ if(this.parent) {
+ return this.parent.find(name, publicOnly, typespace);
+ }
+ return null;
+ };
+ SymbolScopeBuilder.prototype.findAmbient = function (name, publicOnly, typespace) {
+ var sym = null;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable && ((sym = ambientTable.lookup(name)) != null)) {
+ return sym;
+ }
+ if(this.parent) {
+ return this.parent.findAmbient(name, publicOnly, typespace);
+ }
+ return null;
+ };
+ SymbolScopeBuilder.prototype.findLocal = function (name, publicOnly, typespace) {
+ var sym = null;
+ var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(table) {
+ if((sym = table.lookup(name)) != null) {
+ if(sym) {
+ return sym;
+ }
+ }
+ }
+ if(ambientTable) {
+ if((sym = ambientTable.lookup(name)) != null) {
+ if(sym) {
+ return sym;
+ }
+ }
+ }
+ return null;
+ };
+ SymbolScopeBuilder.prototype.enter = function (container, ast, symbol, errorReporter, insertAsPublic, typespace, ambient) {
+ var table = null;
+ if(ambient) {
+ if(typespace) {
+ table = (this.ambientEnclosedTypes == null) ? null : insertAsPublic ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.privateMembers;
+ } else {
+ table = (this.ambientValueMembers == null) ? null : insertAsPublic ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.privateMembers;
+ }
+ } else {
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : insertAsPublic ? this.enclosedTypes.publicMembers : this.enclosedTypes.privateMembers;
+ } else {
+ table = (this.valueMembers == null) ? null : insertAsPublic ? this.valueMembers.publicMembers : this.valueMembers.privateMembers;
+ }
+ }
+ if(table) {
+ if(!table.add(symbol.name, symbol)) {
+ errorReporter.duplicateIdentifier(ast, symbol.name);
+ }
+ } else {
+ TypeScript.CompilerDiagnostics.Alert("YYYYY");
+ }
+ symbol.container = container;
+ };
+ SymbolScopeBuilder.prototype.getTable = function () {
+ return this.valueMembers.allMembers;
+ };
+ return SymbolScopeBuilder;
+ })(SymbolScope);
+ TypeScript.SymbolScopeBuilder = SymbolScopeBuilder;
+ var FilteredSymbolScope = (function (_super) {
+ __extends(FilteredSymbolScope, _super);
+ function FilteredSymbolScope(scope, container, filter) {
+ _super.call(this, container);
+ this.scope = scope;
+ this.filter = filter;
+ }
+ FilteredSymbolScope.prototype.print = function (outfile) {
+ this.scope.print(outfile);
+ };
+ FilteredSymbolScope.prototype.find = function (name, publicOnly, typespace) {
+ this.filter.reset();
+ return this.scope.search(this.filter, name, publicOnly, typespace);
+ };
+ FilteredSymbolScope.prototype.findLocal = function (name, publicOnly, typespace) {
+ return this.scope.findLocal(name, publicOnly, typespace);
+ };
+ return FilteredSymbolScope;
+ })(SymbolScope);
+ TypeScript.FilteredSymbolScope = FilteredSymbolScope;
+ var FilteredSymbolScopeBuilder = (function (_super) {
+ __extends(FilteredSymbolScopeBuilder, _super);
+ function FilteredSymbolScopeBuilder(valueMembers, parent, container, filter) {
+ _super.call(this, valueMembers, null, null, null, parent, container);
+ this.filter = filter;
+ }
+ FilteredSymbolScopeBuilder.prototype.findLocal = function (name, publicOnly, typespace) {
+ var sym = _super.prototype.findLocal.call(this, name, publicOnly, typespace);
+ if(sym) {
+ if(!this.filter(sym)) {
+ return null;
+ }
+ }
+ return sym;
+ };
+ FilteredSymbolScopeBuilder.prototype.search = function (filter, name, publicOnly, typespace) {
+ throw new Error("please implement");
+ };
+ FilteredSymbolScopeBuilder.prototype.find = function (name, publicOnly, typespace) {
+ var sym = _super.prototype.findLocal.call(this, name, publicOnly, typespace);
+ if(sym) {
+ if(!this.filter(sym)) {
+ return null;
+ }
+ }
+ return _super.prototype.find.call(this, name, publicOnly, typespace);
+ };
+ return FilteredSymbolScopeBuilder;
+ })(SymbolScopeBuilder);
+ TypeScript.FilteredSymbolScopeBuilder = FilteredSymbolScopeBuilder;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+ (function (TokenID) {
+ TokenID._map = [];
+ TokenID._map[0] = "Any";
+ TokenID.Any = 0;
+ TokenID._map[1] = "Bool";
+ TokenID.Bool = 1;
+ TokenID._map[2] = "Break";
+ TokenID.Break = 2;
+ TokenID._map[3] = "Case";
+ TokenID.Case = 3;
+ TokenID._map[4] = "Catch";
+ TokenID.Catch = 4;
+ TokenID._map[5] = "Class";
+ TokenID.Class = 5;
+ TokenID._map[6] = "Const";
+ TokenID.Const = 6;
+ TokenID._map[7] = "Continue";
+ TokenID.Continue = 7;
+ TokenID._map[8] = "Debugger";
+ TokenID.Debugger = 8;
+ TokenID._map[9] = "Default";
+ TokenID.Default = 9;
+ TokenID._map[10] = "Delete";
+ TokenID.Delete = 10;
+ TokenID._map[11] = "Do";
+ TokenID.Do = 11;
+ TokenID._map[12] = "Else";
+ TokenID.Else = 12;
+ TokenID._map[13] = "Enum";
+ TokenID.Enum = 13;
+ TokenID._map[14] = "Export";
+ TokenID.Export = 14;
+ TokenID._map[15] = "Extends";
+ TokenID.Extends = 15;
+ TokenID._map[16] = "Declare";
+ TokenID.Declare = 16;
+ TokenID._map[17] = "False";
+ TokenID.False = 17;
+ TokenID._map[18] = "Finally";
+ TokenID.Finally = 18;
+ TokenID._map[19] = "For";
+ TokenID.For = 19;
+ TokenID._map[20] = "Function";
+ TokenID.Function = 20;
+ TokenID._map[21] = "Constructor";
+ TokenID.Constructor = 21;
+ TokenID._map[22] = "Get";
+ TokenID.Get = 22;
+ TokenID._map[23] = "If";
+ TokenID.If = 23;
+ TokenID._map[24] = "Implements";
+ TokenID.Implements = 24;
+ TokenID._map[25] = "Import";
+ TokenID.Import = 25;
+ TokenID._map[26] = "In";
+ TokenID.In = 26;
+ TokenID._map[27] = "InstanceOf";
+ TokenID.InstanceOf = 27;
+ TokenID._map[28] = "Interface";
+ TokenID.Interface = 28;
+ TokenID._map[29] = "Let";
+ TokenID.Let = 29;
+ TokenID._map[30] = "Module";
+ TokenID.Module = 30;
+ TokenID._map[31] = "New";
+ TokenID.New = 31;
+ TokenID._map[32] = "Number";
+ TokenID.Number = 32;
+ TokenID._map[33] = "Null";
+ TokenID.Null = 33;
+ TokenID._map[34] = "Package";
+ TokenID.Package = 34;
+ TokenID._map[35] = "Private";
+ TokenID.Private = 35;
+ TokenID._map[36] = "Protected";
+ TokenID.Protected = 36;
+ TokenID._map[37] = "Public";
+ TokenID.Public = 37;
+ TokenID._map[38] = "Return";
+ TokenID.Return = 38;
+ TokenID._map[39] = "Set";
+ TokenID.Set = 39;
+ TokenID._map[40] = "Static";
+ TokenID.Static = 40;
+ TokenID._map[41] = "String";
+ TokenID.String = 41;
+ TokenID._map[42] = "Super";
+ TokenID.Super = 42;
+ TokenID._map[43] = "Switch";
+ TokenID.Switch = 43;
+ TokenID._map[44] = "This";
+ TokenID.This = 44;
+ TokenID._map[45] = "Throw";
+ TokenID.Throw = 45;
+ TokenID._map[46] = "True";
+ TokenID.True = 46;
+ TokenID._map[47] = "Try";
+ TokenID.Try = 47;
+ TokenID._map[48] = "TypeOf";
+ TokenID.TypeOf = 48;
+ TokenID._map[49] = "Var";
+ TokenID.Var = 49;
+ TokenID._map[50] = "Void";
+ TokenID.Void = 50;
+ TokenID._map[51] = "With";
+ TokenID.With = 51;
+ TokenID._map[52] = "While";
+ TokenID.While = 52;
+ TokenID._map[53] = "Yield";
+ TokenID.Yield = 53;
+ TokenID._map[54] = "Semicolon";
+ TokenID.Semicolon = 54;
+ TokenID._map[55] = "OpenParen";
+ TokenID.OpenParen = 55;
+ TokenID._map[56] = "CloseParen";
+ TokenID.CloseParen = 56;
+ TokenID._map[57] = "OpenBracket";
+ TokenID.OpenBracket = 57;
+ TokenID._map[58] = "CloseBracket";
+ TokenID.CloseBracket = 58;
+ TokenID._map[59] = "OpenBrace";
+ TokenID.OpenBrace = 59;
+ TokenID._map[60] = "CloseBrace";
+ TokenID.CloseBrace = 60;
+ TokenID._map[61] = "Comma";
+ TokenID.Comma = 61;
+ TokenID._map[62] = "Equals";
+ TokenID.Equals = 62;
+ TokenID._map[63] = "PlusEquals";
+ TokenID.PlusEquals = 63;
+ TokenID._map[64] = "MinusEquals";
+ TokenID.MinusEquals = 64;
+ TokenID._map[65] = "AsteriskEquals";
+ TokenID.AsteriskEquals = 65;
+ TokenID._map[66] = "SlashEquals";
+ TokenID.SlashEquals = 66;
+ TokenID._map[67] = "PercentEquals";
+ TokenID.PercentEquals = 67;
+ TokenID._map[68] = "AmpersandEquals";
+ TokenID.AmpersandEquals = 68;
+ TokenID._map[69] = "CaretEquals";
+ TokenID.CaretEquals = 69;
+ TokenID._map[70] = "BarEquals";
+ TokenID.BarEquals = 70;
+ TokenID._map[71] = "LessThanLessThanEquals";
+ TokenID.LessThanLessThanEquals = 71;
+ TokenID._map[72] = "GreaterThanGreaterThanEquals";
+ TokenID.GreaterThanGreaterThanEquals = 72;
+ TokenID._map[73] = "GreaterThanGreaterThanGreaterThanEquals";
+ TokenID.GreaterThanGreaterThanGreaterThanEquals = 73;
+ TokenID._map[74] = "Question";
+ TokenID.Question = 74;
+ TokenID._map[75] = "Colon";
+ TokenID.Colon = 75;
+ TokenID._map[76] = "BarBar";
+ TokenID.BarBar = 76;
+ TokenID._map[77] = "AmpersandAmpersand";
+ TokenID.AmpersandAmpersand = 77;
+ TokenID._map[78] = "Bar";
+ TokenID.Bar = 78;
+ TokenID._map[79] = "Caret";
+ TokenID.Caret = 79;
+ TokenID._map[80] = "And";
+ TokenID.And = 80;
+ TokenID._map[81] = "EqualsEquals";
+ TokenID.EqualsEquals = 81;
+ TokenID._map[82] = "ExclamationEquals";
+ TokenID.ExclamationEquals = 82;
+ TokenID._map[83] = "EqualsEqualsEquals";
+ TokenID.EqualsEqualsEquals = 83;
+ TokenID._map[84] = "ExclamationEqualsEquals";
+ TokenID.ExclamationEqualsEquals = 84;
+ TokenID._map[85] = "LessThan";
+ TokenID.LessThan = 85;
+ TokenID._map[86] = "LessThanEquals";
+ TokenID.LessThanEquals = 86;
+ TokenID._map[87] = "GreaterThan";
+ TokenID.GreaterThan = 87;
+ TokenID._map[88] = "GreaterThanEquals";
+ TokenID.GreaterThanEquals = 88;
+ TokenID._map[89] = "LessThanLessThan";
+ TokenID.LessThanLessThan = 89;
+ TokenID._map[90] = "GreaterThanGreaterThan";
+ TokenID.GreaterThanGreaterThan = 90;
+ TokenID._map[91] = "GreaterThanGreaterThanGreaterThan";
+ TokenID.GreaterThanGreaterThanGreaterThan = 91;
+ TokenID._map[92] = "Plus";
+ TokenID.Plus = 92;
+ TokenID._map[93] = "Minus";
+ TokenID.Minus = 93;
+ TokenID._map[94] = "Asterisk";
+ TokenID.Asterisk = 94;
+ TokenID._map[95] = "Slash";
+ TokenID.Slash = 95;
+ TokenID._map[96] = "Percent";
+ TokenID.Percent = 96;
+ TokenID._map[97] = "Tilde";
+ TokenID.Tilde = 97;
+ TokenID._map[98] = "Exclamation";
+ TokenID.Exclamation = 98;
+ TokenID._map[99] = "PlusPlus";
+ TokenID.PlusPlus = 99;
+ TokenID._map[100] = "MinusMinus";
+ TokenID.MinusMinus = 100;
+ TokenID._map[101] = "Dot";
+ TokenID.Dot = 101;
+ TokenID._map[102] = "DotDotDot";
+ TokenID.DotDotDot = 102;
+ TokenID._map[103] = "Error";
+ TokenID.Error = 103;
+ TokenID._map[104] = "EndOfFile";
+ TokenID.EndOfFile = 104;
+ TokenID._map[105] = "EqualsGreaterThan";
+ TokenID.EqualsGreaterThan = 105;
+ TokenID._map[106] = "Identifier";
+ TokenID.Identifier = 106;
+ TokenID._map[107] = "StringLiteral";
+ TokenID.StringLiteral = 107;
+ TokenID._map[108] = "RegularExpressionLiteral";
+ TokenID.RegularExpressionLiteral = 108;
+ TokenID._map[109] = "NumberLiteral";
+ TokenID.NumberLiteral = 109;
+ TokenID._map[110] = "Whitespace";
+ TokenID.Whitespace = 110;
+ TokenID._map[111] = "Comment";
+ TokenID.Comment = 111;
+ TokenID._map[112] = "Lim";
+ TokenID.Lim = 112;
+ TokenID.LimFixed = TokenID.EqualsGreaterThan;
+ TokenID.LimKeyword = TokenID.Yield;
+ })(TypeScript.TokenID || (TypeScript.TokenID = {}));
+ var TokenID = TypeScript.TokenID;
+ TypeScript.tokenTable = new Array();
+ TypeScript.nodeTypeTable = new Array();
+ TypeScript.nodeTypeToTokTable = new Array();
+ TypeScript.noRegexTable = new Array();
+ TypeScript.noRegexTable[TokenID.Identifier] = true;
+ TypeScript.noRegexTable[TokenID.StringLiteral] = true;
+ TypeScript.noRegexTable[TokenID.NumberLiteral] = true;
+ TypeScript.noRegexTable[TokenID.RegularExpressionLiteral] = true;
+ TypeScript.noRegexTable[TokenID.This] = true;
+ TypeScript.noRegexTable[TokenID.PlusPlus] = true;
+ TypeScript.noRegexTable[TokenID.MinusMinus] = true;
+ TypeScript.noRegexTable[TokenID.CloseParen] = true;
+ TypeScript.noRegexTable[TokenID.CloseBracket] = true;
+ TypeScript.noRegexTable[TokenID.CloseBrace] = true;
+ TypeScript.noRegexTable[TokenID.True] = true;
+ TypeScript.noRegexTable[TokenID.False] = true;
+ (function (OperatorPrecedence) {
+ OperatorPrecedence._map = [];
+ OperatorPrecedence._map[0] = "None";
+ OperatorPrecedence.None = 0;
+ OperatorPrecedence._map[1] = "Comma";
+ OperatorPrecedence.Comma = 1;
+ OperatorPrecedence._map[2] = "Assignment";
+ OperatorPrecedence.Assignment = 2;
+ OperatorPrecedence._map[3] = "Conditional";
+ OperatorPrecedence.Conditional = 3;
+ OperatorPrecedence._map[4] = "LogicalOr";
+ OperatorPrecedence.LogicalOr = 4;
+ OperatorPrecedence._map[5] = "LogicalAnd";
+ OperatorPrecedence.LogicalAnd = 5;
+ OperatorPrecedence._map[6] = "BitwiseOr";
+ OperatorPrecedence.BitwiseOr = 6;
+ OperatorPrecedence._map[7] = "BitwiseExclusiveOr";
+ OperatorPrecedence.BitwiseExclusiveOr = 7;
+ OperatorPrecedence._map[8] = "BitwiseAnd";
+ OperatorPrecedence.BitwiseAnd = 8;
+ OperatorPrecedence._map[9] = "Equality";
+ OperatorPrecedence.Equality = 9;
+ OperatorPrecedence._map[10] = "Relational";
+ OperatorPrecedence.Relational = 10;
+ OperatorPrecedence._map[11] = "Shift";
+ OperatorPrecedence.Shift = 11;
+ OperatorPrecedence._map[12] = "Additive";
+ OperatorPrecedence.Additive = 12;
+ OperatorPrecedence._map[13] = "Multiplicative";
+ OperatorPrecedence.Multiplicative = 13;
+ OperatorPrecedence._map[14] = "Unary";
+ OperatorPrecedence.Unary = 14;
+ OperatorPrecedence._map[15] = "Lim";
+ OperatorPrecedence.Lim = 15;
+ })(TypeScript.OperatorPrecedence || (TypeScript.OperatorPrecedence = {}));
+ var OperatorPrecedence = TypeScript.OperatorPrecedence;
+ (function (Reservation) {
+ Reservation._map = [];
+ Reservation.None = 0;
+ Reservation.Javascript = 1;
+ Reservation.JavascriptFuture = 2;
+ Reservation.TypeScript = 4;
+ Reservation.JavascriptFutureStrict = 8;
+ Reservation.TypeScriptAndJS = Reservation.Javascript | Reservation.TypeScript;
+ Reservation.TypeScriptAndJSFuture = Reservation.JavascriptFuture | Reservation.TypeScript;
+ Reservation.TypeScriptAndJSFutureStrict = Reservation.JavascriptFutureStrict | Reservation.TypeScript;
+ })(TypeScript.Reservation || (TypeScript.Reservation = {}));
+ var Reservation = TypeScript.Reservation;
+ var TokenInfo = (function () {
+ function TokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers) {
+ this.tokenId = tokenId;
+ this.reservation = reservation;
+ this.binopPrecedence = binopPrecedence;
+ this.binopNodeType = binopNodeType;
+ this.unopPrecedence = unopPrecedence;
+ this.unopNodeType = unopNodeType;
+ this.text = text;
+ this.ers = ers;
+ }
+ return TokenInfo;
+ })();
+ TypeScript.TokenInfo = TokenInfo;
+ function setTokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers) {
+ if(tokenId !== undefined) {
+ TypeScript.tokenTable[tokenId] = new TokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers);
+ if(binopNodeType != TypeScript.NodeType.None) {
+ TypeScript.nodeTypeTable[binopNodeType] = text;
+ TypeScript.nodeTypeToTokTable[binopNodeType] = tokenId;
+ }
+ if(unopNodeType != TypeScript.NodeType.None) {
+ TypeScript.nodeTypeTable[unopNodeType] = text;
+ }
+ }
+ }
+ setTokenInfo(TokenID.Any, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "any", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Bool, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "bool", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Break, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "break", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Case, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "case", TypeScript.ErrorRecoverySet.SCase);
+ setTokenInfo(TokenID.Catch, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "catch", TypeScript.ErrorRecoverySet.Catch);
+ setTokenInfo(TokenID.Class, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "class", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Const, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "const", TypeScript.ErrorRecoverySet.Var);
+ setTokenInfo(TokenID.Continue, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "continue", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Debugger, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.Debugger, "debugger", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Default, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "default", TypeScript.ErrorRecoverySet.SCase);
+ setTokenInfo(TokenID.Delete, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Delete, "delete", TypeScript.ErrorRecoverySet.Prefix);
+ setTokenInfo(TokenID.Do, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "do", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Else, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "else", TypeScript.ErrorRecoverySet.Else);
+ setTokenInfo(TokenID.Enum, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "enum", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Export, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "export", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Extends, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "extends", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Declare, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "declare", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.False, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "false", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Finally, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "finally", TypeScript.ErrorRecoverySet.Catch);
+ setTokenInfo(TokenID.For, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "for", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Function, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "function", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.Constructor, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "constructor", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.Get, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "get", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.Set, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "set", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.If, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "if", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Implements, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "implements", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Import, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "import", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.In, Reservation.TypeScriptAndJS, OperatorPrecedence.Relational, TypeScript.NodeType.In, OperatorPrecedence.None, TypeScript.NodeType.None, "in", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.InstanceOf, Reservation.TypeScriptAndJS, OperatorPrecedence.Relational, TypeScript.NodeType.InstOf, OperatorPrecedence.None, TypeScript.NodeType.None, "instanceof", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Interface, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "interface", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Let, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "let", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Module, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "module", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.New, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "new", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.Number, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "number", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Null, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "null", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Package, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "package", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Private, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "private", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Protected, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "protected", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Public, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "public", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Return, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "return", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Static, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "static", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.String, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "string", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Super, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "super", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Switch, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "switch", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.This, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "this", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Throw, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "throw", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.True, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "true", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Try, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "try", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.TypeOf, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Typeof, "typeof", TypeScript.ErrorRecoverySet.Prefix);
+ setTokenInfo(TokenID.Var, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "var", TypeScript.ErrorRecoverySet.Var);
+ setTokenInfo(TokenID.Void, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Void, "void", TypeScript.ErrorRecoverySet.Prefix);
+ setTokenInfo(TokenID.With, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.With, "with", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.While, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "while", TypeScript.ErrorRecoverySet.While);
+ setTokenInfo(TokenID.Yield, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "yield", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Identifier, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "identifier", TypeScript.ErrorRecoverySet.ID);
+ setTokenInfo(TokenID.NumberLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "numberLiteral", TypeScript.ErrorRecoverySet.Literal);
+ setTokenInfo(TokenID.RegularExpressionLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "regex", TypeScript.ErrorRecoverySet.RegExp);
+ setTokenInfo(TokenID.StringLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "qstring", TypeScript.ErrorRecoverySet.Literal);
+ setTokenInfo(TokenID.Semicolon, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ";", TypeScript.ErrorRecoverySet.SColon);
+ setTokenInfo(TokenID.CloseParen, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ")", TypeScript.ErrorRecoverySet.RParen);
+ setTokenInfo(TokenID.CloseBracket, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "]", TypeScript.ErrorRecoverySet.RBrack);
+ setTokenInfo(TokenID.OpenBrace, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "{", TypeScript.ErrorRecoverySet.LCurly);
+ setTokenInfo(TokenID.CloseBrace, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "}", TypeScript.ErrorRecoverySet.RCurly);
+ setTokenInfo(TokenID.DotDotDot, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "...", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Comma, Reservation.None, OperatorPrecedence.Comma, TypeScript.NodeType.Comma, OperatorPrecedence.None, TypeScript.NodeType.None, ",", TypeScript.ErrorRecoverySet.Comma);
+ setTokenInfo(TokenID.Equals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.Asg, OperatorPrecedence.None, TypeScript.NodeType.None, "=", TypeScript.ErrorRecoverySet.Asg);
+ setTokenInfo(TokenID.PlusEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgAdd, OperatorPrecedence.None, TypeScript.NodeType.None, "+=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.MinusEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgSub, OperatorPrecedence.None, TypeScript.NodeType.None, "-=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.AsteriskEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgMul, OperatorPrecedence.None, TypeScript.NodeType.None, "*=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.SlashEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgDiv, OperatorPrecedence.None, TypeScript.NodeType.None, "/=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.PercentEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgMod, OperatorPrecedence.None, TypeScript.NodeType.None, "%=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.AmpersandEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgAnd, OperatorPrecedence.None, TypeScript.NodeType.None, "&=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.CaretEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgXor, OperatorPrecedence.None, TypeScript.NodeType.None, "^=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.BarEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgOr, OperatorPrecedence.None, TypeScript.NodeType.None, "|=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThanLessThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgLsh, OperatorPrecedence.None, TypeScript.NodeType.None, "<<=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgRsh, OperatorPrecedence.None, TypeScript.NodeType.None, ">>=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThanGreaterThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgRs2, OperatorPrecedence.None, TypeScript.NodeType.None, ">>>=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Question, Reservation.None, OperatorPrecedence.Conditional, TypeScript.NodeType.ConditionalExpression, OperatorPrecedence.None, TypeScript.NodeType.None, "?", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Colon, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ":", TypeScript.ErrorRecoverySet.Colon);
+ setTokenInfo(TokenID.BarBar, Reservation.None, OperatorPrecedence.LogicalOr, TypeScript.NodeType.LogOr, OperatorPrecedence.None, TypeScript.NodeType.None, "||", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.AmpersandAmpersand, Reservation.None, OperatorPrecedence.LogicalAnd, TypeScript.NodeType.LogAnd, OperatorPrecedence.None, TypeScript.NodeType.None, "&&", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Bar, Reservation.None, OperatorPrecedence.BitwiseOr, TypeScript.NodeType.Or, OperatorPrecedence.None, TypeScript.NodeType.None, "|", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Caret, Reservation.None, OperatorPrecedence.BitwiseExclusiveOr, TypeScript.NodeType.Xor, OperatorPrecedence.None, TypeScript.NodeType.None, "^", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.And, Reservation.None, OperatorPrecedence.BitwiseAnd, TypeScript.NodeType.And, OperatorPrecedence.None, TypeScript.NodeType.None, "&", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.EqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Eq, OperatorPrecedence.None, TypeScript.NodeType.None, "==", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.ExclamationEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Ne, OperatorPrecedence.None, TypeScript.NodeType.None, "!=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.EqualsEqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Eqv, OperatorPrecedence.None, TypeScript.NodeType.None, "===", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.ExclamationEqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.NEqv, OperatorPrecedence.None, TypeScript.NodeType.None, "!==", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThan, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Lt, OperatorPrecedence.None, TypeScript.NodeType.None, "<", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThanEquals, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Le, OperatorPrecedence.None, TypeScript.NodeType.None, "<=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThan, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Gt, OperatorPrecedence.None, TypeScript.NodeType.None, ">", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanEquals, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Ge, OperatorPrecedence.None, TypeScript.NodeType.None, ">=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThanLessThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Lsh, OperatorPrecedence.None, TypeScript.NodeType.None, "<<", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Rsh, OperatorPrecedence.None, TypeScript.NodeType.None, ">>", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThanGreaterThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Rs2, OperatorPrecedence.None, TypeScript.NodeType.None, ">>>", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Plus, Reservation.None, OperatorPrecedence.Additive, TypeScript.NodeType.Add, OperatorPrecedence.Unary, TypeScript.NodeType.Pos, "+", TypeScript.ErrorRecoverySet.AddOp);
+ setTokenInfo(TokenID.Minus, Reservation.None, OperatorPrecedence.Additive, TypeScript.NodeType.Sub, OperatorPrecedence.Unary, TypeScript.NodeType.Neg, "-", TypeScript.ErrorRecoverySet.AddOp);
+ setTokenInfo(TokenID.Asterisk, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Mul, OperatorPrecedence.None, TypeScript.NodeType.None, "*", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Slash, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Div, OperatorPrecedence.None, TypeScript.NodeType.None, "/", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Percent, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Mod, OperatorPrecedence.None, TypeScript.NodeType.None, "%", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Tilde, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Not, "~", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.Exclamation, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.LogNot, "!", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.PlusPlus, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.IncPre, "++", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.MinusMinus, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.DecPre, "--", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.OpenParen, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "(", TypeScript.ErrorRecoverySet.LParen);
+ setTokenInfo(TokenID.OpenBracket, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "[", TypeScript.ErrorRecoverySet.LBrack);
+ setTokenInfo(TokenID.Dot, Reservation.None, OperatorPrecedence.Unary, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ".", TypeScript.ErrorRecoverySet.Dot);
+ setTokenInfo(TokenID.EndOfFile, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "", TypeScript.ErrorRecoverySet.EOF);
+ setTokenInfo(TokenID.EqualsGreaterThan, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "=>", TypeScript.ErrorRecoverySet.None);
+ function lookupToken(tokenId) {
+ return TypeScript.tokenTable[tokenId];
+ }
+ TypeScript.lookupToken = lookupToken;
+ (function (TokenClass) {
+ TokenClass._map = [];
+ TokenClass._map[0] = "Punctuation";
+ TokenClass.Punctuation = 0;
+ TokenClass._map[1] = "Keyword";
+ TokenClass.Keyword = 1;
+ TokenClass._map[2] = "Operator";
+ TokenClass.Operator = 2;
+ TokenClass._map[3] = "Comment";
+ TokenClass.Comment = 3;
+ TokenClass._map[4] = "Whitespace";
+ TokenClass.Whitespace = 4;
+ TokenClass._map[5] = "Identifier";
+ TokenClass.Identifier = 5;
+ TokenClass._map[6] = "NumberLiteral";
+ TokenClass.NumberLiteral = 6;
+ TokenClass._map[7] = "StringLiteral";
+ TokenClass.StringLiteral = 7;
+ TokenClass._map[8] = "RegExpLiteral";
+ TokenClass.RegExpLiteral = 8;
+ })(TypeScript.TokenClass || (TypeScript.TokenClass = {}));
+ var TokenClass = TypeScript.TokenClass;
+ var SavedToken = (function () {
+ function SavedToken(tok, minChar, limChar) {
+ this.tok = tok;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ }
+ return SavedToken;
+ })();
+ TypeScript.SavedToken = SavedToken;
+ var Token = (function () {
+ function Token(tokenId) {
+ this.tokenId = tokenId;
+ }
+ Token.prototype.toString = function () {
+ return "token: " + this.tokenId + " " + this.getText() + " (" + (TokenID)._map[this.tokenId] + ")";
+ };
+ Token.prototype.print = function (line, outfile) {
+ outfile.WriteLine(this.toString() + ",on line" + line);
+ };
+ Token.prototype.getText = function () {
+ return TypeScript.tokenTable[this.tokenId].text;
+ };
+ Token.prototype.classification = function () {
+ if(this.tokenId <= TokenID.LimKeyword) {
+ return TokenClass.Keyword;
+ } else {
+ var tokenInfo = lookupToken(this.tokenId);
+ if(tokenInfo != undefined) {
+ if((tokenInfo.unopNodeType != TypeScript.NodeType.None) || (tokenInfo.binopNodeType != TypeScript.NodeType.None)) {
+ return TokenClass.Operator;
+ }
+ }
+ }
+ return TokenClass.Punctuation;
+ };
+ return Token;
+ })();
+ TypeScript.Token = Token;
+ var NumberLiteralToken = (function (_super) {
+ __extends(NumberLiteralToken, _super);
+ function NumberLiteralToken(value, text) {
+ _super.call(this, TokenID.NumberLiteral);
+ this.value = value;
+ this.text = text;
+ }
+ NumberLiteralToken.prototype.getText = function () {
+ return this.text;
+ };
+ 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(text) {
+ _super.call(this, TokenID.RegularExpressionLiteral);
+ this.text = text;
+ }
+ RegularExpressionLiteralToken.prototype.getText = function () {
+ return this.text;
+ };
+ 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.Signature);
+ 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 || !symbol.isType()) {
+ 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 && symbol.declAST && symbol.declAST.nodeType != TypeScript.NodeType.ModuleDeclaration) {
+ context.checker.errorReporter.simpleError(moduleDecl, "Conflicting symbol name for module '" + modName + "'");
+ symbol = null;
+ modName = "";
+ }
+ if(symbol) {
+ var modDeclAST = symbol.declAST;
+ var modDeclASTIsExported = TypeScript.hasFlag(modDeclAST.modFlags, TypeScript.ModuleFlags.Exported);
+ if((modDeclASTIsExported && !isExported) || (!modDeclASTIsExported && isExported)) {
+ context.checker.errorReporter.simpleError(moduleDecl, 'All contributions to a module must be "export" or none');
+ }
+ }
+ 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 {
+ 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;
+ }
+ if(fgSym && !fgSym.isAccessor() && funcDecl.isAccessor()) {
+ fgSym = null;
+ }
+ 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;
+ var svCurrentModDecl = this.checker.currentModDecl;
+ 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;
+ }
+ if(type.isModuleType()) {
+ this.checker.currentModDecl = container.declAST;
+ break;
+ }
+ }
+ container = container.container;
+ }
+ this.typeCheckBoundDecl(varDecl);
+ this.checker.currentModDecl = svCurrentModDecl;
+ 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) {
+ 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)) {
+ if(infSym.typeCheckStatus == TypeScript.TypeCheckStatus.Started) {
+ infSym.declAST.type = this.anyType;
+ infSym.setType(this.anyType);
+ } else {
+ 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]);
+ }
+ 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 (constructorDecl, table, isClass) {
+ var container = constructorDecl.type.symbol;
+ var args = constructorDecl.arguments;
+ 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.funcDecl = constructorDecl;
+ 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;
+ }
+ if(funcDecl.classDecl.type.construct == null) {
+ this.checker.errorReporter.simpleError(funcDecl, "Malformed constructor (is this a class named the same as an existing class?)");
+ 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;
+ 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, 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, 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);
+ }
+ var apparentTarget = target.nodeType == TypeScript.NodeType.Dot ? (target).operand2 : target;
+ 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(apparentTarget, "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(apparentTarget, emsg + ":\n\t" + comparisonInfo.message);
+ } else {
+ this.checker.errorReporter.simpleError(apparentTarget, 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(apparentTarget, "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, getPrettyTypeName) {
+ return this.getMemberTypeName("", true, false, scope, getPrettyTypeName);
+ };
+ Type.prototype.getScopedTypeNameEx = function (scope, getPrettyTypeName) {
+ return this.getMemberTypeNameEx("", true, false, scope, getPrettyTypeName);
+ };
+ 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, getPrettyTypeName) {
+ var memberName = this.getMemberTypeNameEx(prefix, topLevel, isElementType, scope, getPrettyTypeName);
+ return memberName.toString();
+ };
+ Type.prototype.getMemberTypeNameEx = function (prefix, topLevel, isElementType, scope, getPrettyTypeName) {
+ 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 getPrettyFunctionOverload = getPrettyTypeName && !curlies && this.call && this.call.signatures.length > 1 && !this.members && !this.construct;
+ var shortform = !curlies && (signatureCount == 1 || getPrettyFunctionOverload) && topLevel;
+ if(this.call) {
+ allMemberNames.addAll(this.call.toStrings(prefix, shortform, scope, getPrettyFunctionOverload));
+ }
+ if(this.construct) {
+ allMemberNames.addAll(this.construct.toStrings("new", shortform, scope));
+ }
+ if(this.index) {
+ allMemberNames.addAll(this.index.toStrings("", shortform, scope));
+ }
+ if((curlies) || (!getPrettyFunctionOverload && (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 isSingleQuoted(str) {
+ return str.indexOf("'") != -1;
+ }
+ TypeScript.isSingleQuoted = isSingleQuoted;
+ function isQuoted(str) {
+ return str.indexOf("\"") != -1 || isSingleQuoted(str);
+ }
+ 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 changeToSingleQuote(str) {
+ if(str.indexOf("\"") != -1) {
+ str = str.replace("\"", "'");
+ str = str.replace("\"", "'");
+ }
+ return str;
+ }
+ TypeScript.changeToSingleQuote = changeToSingleQuote;
+ 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 = [];
+ this.inputOutputMap = [];
+ }
+ 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: null,
+ 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);
+ return false;
+ }
+ } 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 != null) {
+ var rootDir = ioHost.dirName(resolvedFile.path);
+ var sourceUnit = new SourceUnit(resolvedFile.path, resolvedFile.content);
+ var preProcessedFileInfo = TypeScript.preProcessFile(sourceUnit, this.environment.compilationSettings);
+ var resolvedFilePath = ioHost.resolvePath(resolvedFile.path);
+ sourceUnit.referencedFiles = preProcessedFileInfo.referencedFiles;
+ for(var i = 0; i < preProcessedFileInfo.referencedFiles.length; i++) {
+ var fileReference = preProcessedFileInfo.referencedFiles[i];
+ var normalizedPath = TypeScript.isRooted(fileReference.path) ? fileReference.path : rootDir + "/" + fileReference.path;
+ normalizedPath = ioHost.resolvePath(normalizedPath);
+ if(resolvedFilePath == normalizedPath) {
+ resolutionDispatcher.postResolutionError(normalizedPath, fileReference.startLine, fileReference.startCol, "Incorrect reference: File contains reference to itself.");
+ continue;
+ }
+ var resolutionResult = this.resolveCode(fileReference.path, rootDir, false, resolutionDispatcher);
+ if(!resolutionResult) {
+ resolutionDispatcher.postResolutionError(resolvedFilePath, fileReference.startLine, fileReference.startCol, "Incorrect reference: referenced file: \"" + fileReference.path + "\" cannot be resolved.");
+ }
+ }
+ for(var i = 0; i < preProcessedFileInfo.importedFiles.length; i++) {
+ var fileImport = preProcessedFileInfo.importedFiles[i];
+ var resolutionResult = this.resolveCode(fileImport.path, rootDir, true, resolutionDispatcher);
+ if(!resolutionResult) {
+ resolutionDispatcher.postResolutionError(resolvedFilePath, fileImport.startLine, fileImport.startCol, "Incorrect reference: imported file: \"" + fileImport.path + "\" cannot be resolved.");
+ }
+ }
+ resolutionDispatcher.postResolution(sourceUnit.path, sourceUnit);
+ }
+ }
+ return true;
+ };
+ 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.emitFullSourceMapPath = 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*/gim;
+ 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,
+ startLine: 0,
+ startCol: 0,
+ path: TypeScript.switchToForwardSlashes(adjustedPath),
+ isResident: isResident
+ };
+ } else {
+ return null;
+ }
+ }
+ function getAdditionalDependencyPath(comment) {
+ var amdDependencyRegEx = /^(\/\/\/\s*/gim;
+ 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*/gim;
+ var match = implicitImportRegEx.exec(comment);
+ if(match) {
+ return true;
+ }
+ return false;
+ }
+ TypeScript.getImplicitImport = getImplicitImport;
+ function getStyleSettings(comment, styleSettings) {
+ var styleRegEx = /^(\/\/\/\s*/gim;
+ var settings = styleRegEx.exec(comment);
+ if(settings) {
+ var settingsRegEx = /^([a-zA-Z]+=['"]on['|"])/gim;
+ 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,
+ startLine: scanner.line,
+ startCol: scanner.col,
+ 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;
+ var result = {
+ line: -1,
+ col: -1
+ };
+ TypeScript.getSourceLineColFromMap(result, comment.startPos, scanner.lineMap);
+ if(result.col >= 0) {
+ result.col++;
+ }
+ referencedCode.startLine = result.line;
+ referencedCode.startCol = result.col;
+ referencedFiles.push(referencedCode);
+ }
+ if(settings) {
+ getStyleSettings(comment.getText(), settings.styleSettings);
+ var isNoLibRegex = /^(\/\/\/\s*/gim;
+ 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)) {
+ if(TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.Private)) {
+ result += "private ";
+ }
+ 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");
+ if(id != "__missing" || !funcDecl.name || !funcDecl.name.isMissing()) {
+ this.declFile.Write(id);
+ } else if(funcDecl.isConstructMember()) {
+ this.declFile.Write("new");
+ }
+ } else {
+ this.emitIndent();
+ if(funcDecl.isConstructMember()) {
+ this.declFile.Write("new");
+ } else if(!funcDecl.isCallMember() && !funcDecl.isIndexerMember()) {
+ this.declFile.Write(id);
+ if(TypeScript.hasFlag(funcDecl.name.flags, TypeScript.ASTFlags.OptionalName)) {
+ this.declFile.Write("? ");
+ }
+ }
+ }
+ }
+ if(!funcDecl.isIndexerMember()) {
+ this.declFile.Write("(");
+ } else {
+ this.declFile.Write("[");
+ }
+ this.indenter.increaseIndent();
+ if(funcDecl.arguments) {
+ var argsLen = funcDecl.arguments.members.length;
+ if(funcDecl.variableArgList) {
+ argsLen--;
+ }
+ for(var i = 0; i < argsLen; i++) {
+ var argDecl = funcDecl.arguments.members[i];
+ this.emitArgDecl(argDecl, funcDecl);
+ if(i < (argsLen - 1)) {
+ this.declFile.Write(", ");
+ }
+ }
+ }
+ if(funcDecl.variableArgList) {
+ var lastArg = funcDecl.arguments.members[funcDecl.arguments.members.length - 1];
+ if(funcDecl.arguments.members.length > 1) {
+ this.declFile.Write(", ...");
+ } else {
+ this.declFile.Write("...");
+ }
+ this.emitArgDecl(lastArg, funcDecl);
+ }
+ this.indenter.decreaseIndent();
+ if(!funcDecl.isIndexerMember()) {
+ this.declFile.Write(")");
+ } else {
+ this.declFile.Write("]");
+ }
+ if(!funcDecl.isConstructor && (funcDecl.returnTypeAnnotation || funcDecl.signature.returnType.type != this.checker.anyType) && this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(funcDecl.fncFlags))) {
+ this.declFile.Write(": ");
+ this.emitTypeSignature(funcDecl.signature.returnType.type);
+ }
+ this.declFile.WriteLine(";");
+ return false;
+ };
+ DeclarationEmitter.prototype.emitBaseList = function (bases, qual) {
+ if(bases && (bases.members.length > 0)) {
+ this.declFile.Write(" " + qual + " ");
+ var basesLen = bases.members.length;
+ for(var i = 0; i < basesLen; i++) {
+ var baseExpr = bases.members[i];
+ var baseSymbol = baseExpr.type.symbol;
+ var baseType = baseExpr.type;
+ if(i > 0) {
+ this.declFile.Write(", ");
+ }
+ this.emitTypeSignature(baseType);
+ }
+ }
+ };
+ DeclarationEmitter.prototype.emitPropertyAccessorSignature = function (funcDecl) {
+ var accessorSymbol = funcDecl.accessorSymbol;
+ if(accessorSymbol.getter && accessorSymbol.getter.declAST != funcDecl) {
+ return false;
+ }
+ this.emitDeclarationComments(accessorSymbol);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(accessorSymbol.flags), "var");
+ this.declFile.Write(funcDecl.name.text);
+ var propertyType = accessorSymbol.getType();
+ if(this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(accessorSymbol.flags))) {
+ this.declFile.Write(" : ");
+ this.emitTypeSignature(propertyType);
+ }
+ this.declFile.WriteLine(";");
+ return false;
+ };
+ DeclarationEmitter.prototype.emitClassMembersFromConstructorDefinition = function (funcDecl) {
+ if(funcDecl.arguments) {
+ var argsLen = funcDecl.arguments.members.length;
+ if(funcDecl.variableArgList) {
+ argsLen--;
+ }
+ for(var i = 0; i < argsLen; i++) {
+ var argDecl = funcDecl.arguments.members[i];
+ if(TypeScript.hasFlag(argDecl.varFlags, TypeScript.VarFlags.Property)) {
+ this.emitDeclarationComments(argDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(argDecl.varFlags), "var");
+ this.declFile.Write(argDecl.id.text);
+ if(argDecl.typeExpr && this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(argDecl.varFlags))) {
+ this.declFile.Write(": ");
+ this.emitTypeSignature(argDecl.type);
+ }
+ this.declFile.WriteLine(";");
+ }
+ }
+ }
+ };
+ DeclarationEmitter.prototype.ClassDeclarationCallback = function (pre, classDecl) {
+ if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(classDecl.varFlags), classDecl, pre)) {
+ return false;
+ }
+ if(pre) {
+ var className = classDecl.name.text;
+ this.emitDeclarationComments(classDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(classDecl.varFlags), "class");
+ this.declFile.Write(className);
+ this.emitBaseList(classDecl.extendsList, "extends");
+ this.emitBaseList(classDecl.implementsList, "implements");
+ this.declFile.WriteLine(" {");
+ this.pushDeclarationContainer(classDecl);
+ this.indenter.increaseIndent();
+ if(classDecl.constructorDecl) {
+ this.emitClassMembersFromConstructorDefinition(classDecl.constructorDecl);
+ }
+ } else {
+ this.indenter.decreaseIndent();
+ this.popDeclarationContainer(classDecl);
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.InterfaceDeclarationCallback = function (pre, interfaceDecl) {
+ if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(interfaceDecl.varFlags), interfaceDecl, pre)) {
+ return false;
+ }
+ if(pre) {
+ var interfaceName = interfaceDecl.name.text;
+ this.emitDeclarationComments(interfaceDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(interfaceDecl.varFlags), "interface");
+ this.declFile.Write(interfaceName);
+ this.emitBaseList(interfaceDecl.extendsList, "extends");
+ this.declFile.WriteLine(" {");
+ this.indenter.increaseIndent();
+ this.pushDeclarationContainer(interfaceDecl);
+ } else {
+ this.indenter.decreaseIndent();
+ this.popDeclarationContainer(interfaceDecl);
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.ImportDeclarationCallback = function (pre, importDecl) {
+ if(pre) {
+ if((this.declarationContainerStack[0]).isExternallyVisibleSymbol(importDecl.id.sym)) {
+ this.emitDeclarationComments(importDecl);
+ this.emitIndent();
+ this.declFile.Write("import ");
+ this.declFile.Write(importDecl.id.text + " = ");
+ if(importDecl.isDynamicImport) {
+ this.declFile.WriteLine("module (" + importDecl.getAliasName() + ");");
+ } else {
+ this.declFile.WriteLine(importDecl.getAliasName() + ";");
+ }
+ }
+ }
+ return false;
+ };
+ DeclarationEmitter.prototype.emitEnumSignature = function (moduleDecl) {
+ if(!this.canEmitSignature(TypeScript.ToDeclFlags(moduleDecl.modFlags))) {
+ return false;
+ }
+ this.emitDeclarationComments(moduleDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(moduleDecl.modFlags), "enum");
+ this.declFile.WriteLine(moduleDecl.name.text + " {");
+ this.indenter.increaseIndent();
+ var membersLen = moduleDecl.members.members.length;
+ for(var j = 1; j < membersLen; j++) {
+ var memberDecl = moduleDecl.members.members[j];
+ if(memberDecl.nodeType == TypeScript.NodeType.VarDecl) {
+ this.emitDeclarationComments(memberDecl);
+ this.emitIndent();
+ this.declFile.WriteLine((memberDecl).id.text + ",");
+ } else {
+ TypeScript.CompilerDiagnostics.assert(memberDecl.nodeType != TypeScript.NodeType.Asg, "We want to catch this");
+ }
+ }
+ this.indenter.decreaseIndent();
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ return false;
+ };
+ DeclarationEmitter.prototype.ModuleDeclarationCallback = function (pre, moduleDecl) {
+ if(TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsWholeFile)) {
+ if(TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsDynamic)) {
+ if(pre) {
+ if(!this.emitOptions.outputMany) {
+ this.singleDeclFile = this.declFile;
+ TypeScript.CompilerDiagnostics.assert(this.indenter.indentAmt == 0, "Indent has to be 0 when outputing new file");
+ var declareFileName = this.emitOptions.mapOutputFileName(TypeScript.stripQuotes(moduleDecl.name.sym.name), TypeScript.TypeScriptCompiler.mapToDTSFileName);
+ var useUTF8InOutputfile = moduleDecl.containsUnicodeChar || (this.emitOptions.emitComments && moduleDecl.containsUnicodeCharInComment);
+ try {
+ this.declFile = new DeclFileWriter(this.emitOptions.ioHost.createFile(declareFileName, useUTF8InOutputfile));
+ } catch (ex) {
+ this.errorReporter.emitterError(null, ex.message);
+ }
+ }
+ this.pushDeclarationContainer(moduleDecl);
+ } else {
+ if(!this.emitOptions.outputMany) {
+ TypeScript.CompilerDiagnostics.assert(this.singleDeclFile != this.declFile, "singleDeclFile cannot be null as we are going to revert back to it");
+ TypeScript.CompilerDiagnostics.assert(this.indenter.indentAmt == 0, "Indent has to be 0 when outputing new file");
+ try {
+ this.declFile.Close();
+ } catch (ex) {
+ this.errorReporter.emitterError(null, ex.message);
+ }
+ this.declFile = this.singleDeclFile;
+ }
+ this.popDeclarationContainer(moduleDecl);
+ }
+ }
+ return true;
+ }
+ if(moduleDecl.isEnum()) {
+ if(pre) {
+ this.emitEnumSignature(moduleDecl);
+ }
+ return false;
+ }
+ if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(moduleDecl.modFlags), moduleDecl, pre)) {
+ return false;
+ }
+ if(pre) {
+ if(this.emitDottedModuleName()) {
+ this.dottedModuleEmit += ".";
+ } else {
+ this.dottedModuleEmit = this.getDeclFlagsString(TypeScript.ToDeclFlags(moduleDecl.modFlags), "module");
+ }
+ this.dottedModuleEmit += moduleDecl.name.text;
+ var isCurrentModuleDotted = (moduleDecl.members.members.length == 1 && moduleDecl.members.members[0].nodeType == TypeScript.NodeType.ModuleDeclaration && !(moduleDecl.members.members[0]).isEnum() && TypeScript.hasFlag((moduleDecl.members.members[0]).modFlags, TypeScript.ModuleFlags.Exported));
+ var moduleDeclComments = moduleDecl.getDocComments();
+ isCurrentModuleDotted = isCurrentModuleDotted && (moduleDeclComments == null || moduleDeclComments.length == 0);
+ this.isDottedModuleName.push(isCurrentModuleDotted);
+ this.pushDeclarationContainer(moduleDecl);
+ if(!isCurrentModuleDotted) {
+ this.emitDeclarationComments(moduleDecl);
+ this.declFile.Write(this.dottedModuleEmit);
+ this.declFile.WriteLine(" {");
+ this.indenter.increaseIndent();
+ }
+ } else {
+ if(!this.emitDottedModuleName()) {
+ this.indenter.decreaseIndent();
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ }
+ this.popDeclarationContainer(moduleDecl);
+ this.isDottedModuleName.pop();
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.ScriptCallback = function (pre, script) {
+ if(pre) {
+ if(this.emitOptions.outputMany) {
+ for(var i = 0; i < script.referencedFiles.length; i++) {
+ var referencePath = script.referencedFiles[i].path;
+ var declareFileName;
+ if(TypeScript.isRooted(referencePath)) {
+ declareFileName = this.emitOptions.mapOutputFileName(referencePath, TypeScript.TypeScriptCompiler.mapToDTSFileName);
+ } else {
+ declareFileName = TypeScript.getDeclareFilePath(script.referencedFiles[i].path);
+ }
+ this.declFile.WriteLine('/// ');
+ }
+ }
+ this.pushDeclarationContainer(script);
+ } else {
+ this.popDeclarationContainer(script);
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.DefaultCallback = function (pre, ast) {
+ return !TypeScript.hasFlag(ast.flags, TypeScript.ASTFlags.IsStatement);
+ };
+ return DeclarationEmitter;
+ })();
+ TypeScript.DeclarationEmitter = DeclarationEmitter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+ (function (UpdateUnitKind) {
+ UpdateUnitKind._map = [];
+ UpdateUnitKind._map[0] = "Unknown";
+ UpdateUnitKind.Unknown = 0;
+ UpdateUnitKind._map[1] = "NoEdits";
+ UpdateUnitKind.NoEdits = 1;
+ UpdateUnitKind._map[2] = "EditsInsideSingleScope";
+ UpdateUnitKind.EditsInsideSingleScope = 2;
+ })(TypeScript.UpdateUnitKind || (TypeScript.UpdateUnitKind = {}));
+ var UpdateUnitKind = TypeScript.UpdateUnitKind;
+ var ScriptEditRange = (function () {
+ function ScriptEditRange(minChar, limChar, delta) {
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.delta = delta;
+ }
+ ScriptEditRange.unknown = function unknown() {
+ return new ScriptEditRange(-1, -1, -1);
+ };
+ ScriptEditRange.prototype.isUnknown = function () {
+ return this.minChar === -1 && this.limChar === -1 && this.delta === -1;
+ };
+ ScriptEditRange.prototype.containsPosition = function (pos) {
+ return (this.minChar <= pos && pos < this.limChar) || (this.minChar <= pos && pos < this.limChar + this.delta);
+ };
+ ScriptEditRange.prototype.toString = function () {
+ return "editRange(minChar=" + this.minChar + ", limChar=" + this.limChar + ", delta=" + this.delta + ")";
+ };
+ return ScriptEditRange;
+ })();
+ TypeScript.ScriptEditRange = ScriptEditRange;
+ var UpdateUnitResult = (function () {
+ function UpdateUnitResult(kind, unitIndex, script1, script2) {
+ this.kind = kind;
+ this.unitIndex = unitIndex;
+ this.script1 = script1;
+ this.script2 = script2;
+ this.scope1 = null;
+ this.scope2 = null;
+ this.editRange = null;
+ this.parseErrors = [];
+ }
+ UpdateUnitResult.noEdits = function noEdits(unitIndex) {
+ return new UpdateUnitResult(UpdateUnitKind.NoEdits, unitIndex, null, null);
+ };
+ UpdateUnitResult.unknownEdits = function unknownEdits(script1, script2, parseErrors) {
+ var result = new UpdateUnitResult(UpdateUnitKind.Unknown, script1.locationInfo.unitIndex, script1, script2);
+ result.parseErrors = parseErrors;
+ return result;
+ };
+ UpdateUnitResult.singleScopeEdits = function singleScopeEdits(script1, script2, scope1, scope2, editRange, parseErrors) {
+ var result = new UpdateUnitResult(UpdateUnitKind.EditsInsideSingleScope, script1.locationInfo.unitIndex, script1, script2);
+ result.scope1 = scope1;
+ result.scope2 = scope2;
+ result.editRange = editRange;
+ result.parseErrors = parseErrors;
+ return result;
+ };
+ return UpdateUnitResult;
+ })();
+ TypeScript.UpdateUnitResult = UpdateUnitResult;
+ var ErrorEntry = (function () {
+ function ErrorEntry(unitIndex, minChar, limChar, message) {
+ this.unitIndex = unitIndex;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.message = message;
+ }
+ return ErrorEntry;
+ })();
+ TypeScript.ErrorEntry = ErrorEntry;
+ TypeScript.defaultSettings = new TypeScript.CompilationSettings();
+ var TypeScriptCompiler = (function () {
+ function TypeScriptCompiler(errorOutput, logger, settings) {
+ if (typeof logger === "undefined") { logger = new TypeScript.NullLogger(); }
+ if (typeof settings === "undefined") { settings = TypeScript.defaultSettings; }
+ this.errorOutput = errorOutput;
+ this.logger = logger;
+ this.settings = settings;
+ this.parser = new TypeScript.Parser();
+ this.typeFlow = null;
+ this.scripts = new TypeScript.ASTList();
+ this.units = new Array();
+ this.errorReporter = new TypeScript.ErrorReporter(this.errorOutput);
+ this.persistentTypeState = new TypeScript.PersistentGlobalTypeState(this.errorReporter);
+ this.errorReporter.parser = this.parser;
+ this.initTypeChecker(this.errorOutput);
+ this.parser.style_requireSemi = this.settings.styleSettings.requireSemi;
+ this.parser.style_funcInLoop = this.settings.styleSettings.funcInLoop;
+ this.parser.inferPropertiesFromThisAssignment = this.settings.inferPropertiesFromThisAssignment;
+ this.emitSettings = new TypeScript.EmitOptions(this.settings);
+ TypeScript.codeGenTarget = settings.codeGenTarget;
+ }
+ TypeScriptCompiler.prototype.timeFunction = function (funcDescription, func) {
+ return TypeScript.timeFunction(this.logger, funcDescription, func);
+ };
+ TypeScriptCompiler.prototype.initTypeChecker = function (errorOutput) {
+ this.persistentTypeState.refreshPersistentState();
+ this.typeChecker = new TypeScript.TypeChecker(this.persistentTypeState);
+ this.typeChecker.errorReporter = this.errorReporter;
+ this.typeChecker.checkControlFlow = this.settings.controlFlow;
+ this.typeChecker.checkControlFlowUseDef = this.settings.controlFlowUseDef;
+ this.typeChecker.printControlFlowGraph = this.settings.printControlFlow;
+ this.typeChecker.errorsOnWith = this.settings.errorOnWith;
+ this.typeChecker.styleSettings = this.settings.styleSettings;
+ this.typeChecker.canCallDefinitionSignature = this.settings.canCallDefinitionSignature;
+ this.errorReporter.checker = this.typeChecker;
+ this.setErrorOutput(this.errorOutput);
+ };
+ TypeScriptCompiler.prototype.setErrorOutput = function (outerr) {
+ this.errorOutput = outerr;
+ this.errorReporter.setErrOut(outerr);
+ this.parser.outfile = outerr;
+ };
+ TypeScriptCompiler.prototype.emitCommentsToOutput = function () {
+ this.emitSettings = new TypeScript.EmitOptions(this.settings);
+ };
+ TypeScriptCompiler.prototype.setErrorCallback = function (fn) {
+ this.parser.errorCallback = fn;
+ };
+ TypeScriptCompiler.prototype.updateUnit = function (prog, filename, setRecovery) {
+ return this.updateSourceUnit(new TypeScript.StringSourceText(prog), filename, setRecovery);
+ };
+ TypeScriptCompiler.prototype.updateSourceUnit = function (sourceText, filename, setRecovery) {
+ var _this = this;
+ return this.timeFunction("updateSourceUnit(" + filename + ")", function () {
+ var updateResult = _this.partialUpdateUnit(sourceText, filename, setRecovery);
+ return _this.applyUpdateResult(updateResult);
+ });
+ };
+ TypeScriptCompiler.prototype.applyUpdateResult = function (updateResult) {
+ switch(updateResult.kind) {
+ case UpdateUnitKind.NoEdits:
+ return false;
+ case UpdateUnitKind.Unknown:
+ this.scripts.members[updateResult.unitIndex] = updateResult.script2;
+ this.units[updateResult.unitIndex] = updateResult.script2.locationInfo;
+ for(var i = 0, len = updateResult.parseErrors.length; i < len; i++) {
+ var e = updateResult.parseErrors[i];
+ if(this.parser.errorCallback) {
+ this.parser.errorCallback(e.minChar, e.limChar - e.minChar, e.message, e.unitIndex);
+ }
+ }
+ return true;
+ case UpdateUnitKind.EditsInsideSingleScope:
+ new TypeScript.IncrementalParser(this.logger).mergeTrees(updateResult);
+ return true;
+ }
+ };
+ TypeScriptCompiler.prototype.partialUpdateUnit = function (sourceText, filename, setRecovery) {
+ var _this = this;
+ return this.timeFunction("partialUpdateUnit(" + filename + ")", function () {
+ for(var i = 0, len = _this.units.length; i < len; i++) {
+ if(_this.units[i].filename == filename) {
+ if((_this.scripts.members[i]).isResident) {
+ return UpdateUnitResult.noEdits(i);
+ }
+ if(setRecovery) {
+ _this.parser.setErrorRecovery(null);
+ }
+ var updateResult;
+ var parseErrors = [];
+ var errorCapture = function (minChar, charLen, message, unitIndex) {
+ parseErrors.push(new ErrorEntry(unitIndex, minChar, minChar + charLen, message));
+ };
+ var svErrorCallback = _this.parser.errorCallback;
+ if(svErrorCallback) {
+ _this.parser.errorCallback = errorCapture;
+ }
+ var oldScript = _this.scripts.members[i];
+ var newScript = _this.parser.parse(sourceText, filename, i);
+ if(svErrorCallback) {
+ _this.parser.errorCallback = svErrorCallback;
+ }
+ updateResult = UpdateUnitResult.unknownEdits(oldScript, newScript, parseErrors);
+ return updateResult;
+ }
+ }
+ throw new Error("Unknown file \"" + filename + "\"");
+ });
+ };
+ TypeScriptCompiler.prototype.addUnit = function (prog, filename, keepResident, referencedFiles) {
+ if (typeof keepResident === "undefined") { keepResident = false; }
+ if (typeof referencedFiles === "undefined") { referencedFiles = []; }
+ return this.addSourceUnit(new TypeScript.StringSourceText(prog), filename, keepResident, referencedFiles);
+ };
+ TypeScriptCompiler.prototype.addSourceUnit = function (sourceText, filename, keepResident, referencedFiles) {
+ if (typeof referencedFiles === "undefined") { referencedFiles = []; }
+ var _this = this;
+ return this.timeFunction("addSourceUnit(" + filename + ", " + keepResident + ")", function () {
+ var script = _this.parser.parse(sourceText, filename, _this.units.length, TypeScript.AllowedElements.Global);
+ script.referencedFiles = referencedFiles;
+ script.isResident = keepResident;
+ _this.persistentTypeState.setCollectionMode(keepResident ? TypeScript.TypeCheckCollectionMode.Resident : TypeScript.TypeCheckCollectionMode.Transient);
+ var index = _this.units.length;
+ _this.units[index] = script.locationInfo;
+ _this.typeChecker.collectTypes(script);
+ _this.scripts.append(script);
+ return script;
+ });
+ };
+ TypeScriptCompiler.prototype.parseUnit = function (prog, filename) {
+ return this.parseSourceUnit(new TypeScript.StringSourceText(prog), filename);
+ };
+ TypeScriptCompiler.prototype.parseSourceUnit = function (sourceText, filename) {
+ this.parser.setErrorRecovery(this.errorOutput);
+ var script = this.parser.parse(sourceText, filename, 0);
+ var index = this.units.length;
+ this.units[index] = script.locationInfo;
+ this.typeChecker.collectTypes(script);
+ this.scripts.append(script);
+ };
+ TypeScriptCompiler.prototype.typeCheck = function () {
+ var _this = this;
+ return this.timeFunction("typeCheck()", function () {
+ var binder = new TypeScript.Binder(_this.typeChecker);
+ _this.typeChecker.units = _this.units;
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.globals);
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.ambientGlobals);
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.globalTypes);
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.ambientGlobalTypes);
+ _this.typeFlow = new TypeScript.TypeFlow(_this.logger, _this.typeChecker.globalScope, _this.parser, _this.typeChecker);
+ var i = 0;
+ var script = null;
+ var len = _this.scripts.members.length;
+ _this.persistentTypeState.setCollectionMode(TypeScript.TypeCheckCollectionMode.Resident);
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(!script.isResident || script.hasBeenTypeChecked) {
+ continue;
+ }
+ _this.typeFlow.assignScopes(script);
+ _this.typeFlow.initLibs();
+ }
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(!script.isResident || script.hasBeenTypeChecked) {
+ continue;
+ }
+ _this.typeFlow.typeCheck(script);
+ script.hasBeenTypeChecked = true;
+ }
+ _this.persistentTypeState.setCollectionMode(TypeScript.TypeCheckCollectionMode.Transient);
+ len = _this.scripts.members.length;
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(script.isResident) {
+ continue;
+ }
+ _this.typeFlow.assignScopes(script);
+ _this.typeFlow.initLibs();
+ }
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(script.isResident) {
+ continue;
+ }
+ _this.typeFlow.typeCheck(script);
+ }
+ return null;
+ });
+ };
+ TypeScriptCompiler.prototype.cleanASTTypesForReTypeCheck = function (ast) {
+ function cleanASTType(ast, parent) {
+ ast.type = null;
+ if(ast.nodeType == TypeScript.NodeType.VarDecl) {
+ var vardecl = ast;
+ vardecl.sym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.ArgDecl) {
+ var argdecl = ast;
+ argdecl.sym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.Name) {
+ var name = ast;
+ name.sym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.FuncDecl) {
+ var funcdecl = ast;
+ funcdecl.signature = null;
+ funcdecl.freeVariables = new Array();
+ funcdecl.symbols = null;
+ funcdecl.accessorSymbol = null;
+ funcdecl.scopeType = null;
+ } else if(ast.nodeType == TypeScript.NodeType.ModuleDeclaration) {
+ var modDecl = ast;
+ modDecl.mod = null;
+ } else if(ast.nodeType == TypeScript.NodeType.With) {
+ (ast).withSym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.Catch) {
+ (ast).containedScope = null;
+ } else if(ast.nodeType === TypeScript.NodeType.Script) {
+ (ast).externallyVisibleImportedSymbols = [];
+ }
+ 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, inputOutputMapper) {
+ 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, this.settings.emitFullSourceMapPath));
+ }
+ if(inputOutputMapper) {
+ inputOutputMapper(script.locationInfo.unitIndex, outFname);
+ }
+ } else if(this.settings.mapSourceFiles) {
+ emitter.setSourceMappings(new TypeScript.SourceMapper(fname, emitter.emittingFileName, emitter.outfile, emitter.sourceMapper.sourceMapOut, this.errorReporter, this.settings.emitFullSourceMapPath));
+ }
+ 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, inputOutputMapper) {
+ 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, null, inputOutputMapper);
+ } 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, getPrettyTypeName) {
+ 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, getPrettyTypeName);
+ this.compiler.typeChecker.currentModDecl = svModuleDecl;
+ return result;
+ };
+ ScopeTraversal.prototype.getTypeNamesForNames = function (enclosingScopeContext, allNames, scope, getPrettyTypeName) {
+ 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 getPrettyOverload = getPrettyTypeName && symbol.declAST && symbol.declAST.nodeType == TypeScript.NodeType.FuncDecl;
+ var type = symbol.getType();
+ var typeName = type ? type.getScopedTypeName(enclosingScope, getPrettyOverload) : "";
+ 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 0x09:
+ result += "\\t";
+ break;
+ case 0x0a:
+ result += "\\n";
+ break;
+ case 0x0b:
+ result += "\\v";
+ break;
+ case 0x0c:
+ result += "\\f";
+ break;
+ case 0x0d:
+ result += "\\r";
+ break;
+ case 0x22:
+ result += "\\\"";
+ break;
+ case 0x27:
+ result += "\\\'";
+ break;
+ case 0x5c:
+ 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 = {}));
diff --git a/bin/typescriptServices.js b/bin/typescriptServices.js
new file mode 100644
index 0000000..3fba95a
--- /dev/null
+++ b/bin/typescriptServices.js
@@ -0,0 +1,32848 @@
+/* *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+/*----------------- TypeScript ThirdPartyNotices -------------------------------------------------------
+
+The TypeScript software is based on or incorporates material and code from the projects listed below
+(collectively "Third Party Code"). Microsoft is not the original author of the
+Third Party Code. The original copyright notice and the license, under which
+Microsoft received such Third Party Code, are set forth below. Such license and
+notices are provided for informational purposes only. Microsoft licenses the Third
+Party Code to you under the terms of the Apache 2.0 License.
+All Third Party Code licensed by Microsoft under the Apache License, Version 2.0 (the "License"); you
+may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OR
+CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions and
+limitations under the License.
+---------------------------------------------
+Third Party Code Components
+--------------------------------------------
+---- Mozilla Developer Code---------
+The following Mozilla Developer Code is under Public Domain as updated after Aug. 20, 2012, see, https://developer.mozilla.org/en-US/docs/Project:Copyrights
+1. Array filter Compatibility Method,
+Available at https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/filter
+Any copyright is dedicated to the Public Domain.
+
+2. Array forEach Compatibility Method,
+Available at https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/forEach
+Any copyright is dedicated to the Public Domain.
+
+3. Array indexOf Compatibility Method,
+Available at https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf
+Any copyright is dedicated to the Public Domain.
+
+4. Array map Compatibility Method,
+Available at https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/map
+Any copyright is dedicated to the Public Domain.
+
+5. Array Reduce Compatibility Method,
+Available at https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/Reduce
+Any copyright is dedicated to the Public Domain.
+
+6. String Trim Compatibility Method,
+Available at https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/Trim
+Any copyright is dedicated to the Public Domain.
+
+7. Date now Compatibility Method,
+Available at https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date/now
+Any copyright is dedicated to the Public Domain.
+
+------------JSON2 Script------------------------
+json2.js 2012-10-08
+Public Domain.
+NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+See, http://www.JSON.org/js.html
+
+--------------r.js----------------------
+Copyright (c) 2010-2011 Dojo Foundation. All Rights Reserved.
+Originally License under MIT License
+-------------------------------------------------------------------------
+Provided for Informational Purposes Only
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+--------------------------------------------------------------------------------------
+
+------------- End of ThirdPartyNotices --------------------------------------------------- */
+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.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 = 0x27d4eb2d;
+ 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, text) {
+ _super.call(this, TypeScript.NodeType.NumberLit);
+ this.value = value;
+ this.text = text;
+ }
+ 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);
+ emitter.writeToOutput(this.text);
+ emitter.recordSourceMappingEnd(this);
+ emitter.emitParensAndCommentsInPlace(this, false);
+ };
+ NumberLiteral.prototype.printLabel = function () {
+ return this.text;
+ };
+ return NumberLiteral;
+ })(Expression);
+ TypeScript.NumberLiteral = NumberLiteral;
+ var RegexLiteral = (function (_super) {
+ __extends(RegexLiteral, _super);
+ function RegexLiteral(text) {
+ _super.call(this, TypeScript.NodeType.Regex);
+ this.text = text;
+ }
+ 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.text);
+ 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.isInlineCallLiteral = false;
+ this.accessorSymbol = null;
+ this.leftCurlyCount = 0;
+ this.rightCurlyCount = 0;
+ this.returnStatementsWithExpressions = [];
+ this.scopeType = null;
+ this.endingToken = null;
+ this.constructorSpan = 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;
+ }
+ 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) {
+ if(this.bod.members.length == 0) {
+ return this.setCachedEmitRequired(true);
+ }
+ 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.emitJavascriptList(this.bod, null, TypeScript.TokenID.Semicolon, true, false, false, true, this.requiresExtendsBlock);
+ }
+ };
+ 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, 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.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.isWholeFile = function () {
+ return TypeScript.hasFlag(this.modFlags, TypeScript.ModuleFlags.IsWholeFile);
+ };
+ 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.emitJavascriptModule(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;
+ this.colonSpan = new ASTSpan();
+ }
+ 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.recordSourceMappingStart(this.colonSpan);
+ emitter.writeToOutput(":");
+ emitter.recordSourceMappingEnd(this.colonSpan);
+ 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) == "*" && this.content.charAt(3) != "/";
+ }
+ 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.getDocCommentFirstOverloadSignature = function getDocCommentFirstOverloadSignature(signatureGroup) {
+ for(var i = 0; i < signatureGroup.signatures.length; i++) {
+ var signature = signatureGroup.signatures[i];
+ if(signature == signatureGroup.definitionSignature) {
+ continue;
+ }
+ return TypeScript.Comment.getDocCommentText(signature.declAST.getDocComments());
+ }
+ return "";
+ };
+ 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.writeToOutput("debugger");
+ emitter.recordSourceMappingEnd(this);
+ emitter.writeLineToOutput(";");
+ 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 && (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 && (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);
+ }
+ var callAndConstructScope = scope;
+ 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);
+ }
+ if(type.isModuleType()) {
+ callAndConstructScope = agg;
+ }
+ this.checker.currentModDecl = prevCurrentModDecl;
+ this.checker.inBind = prevBindStatus;
+ }
+ if(type.extendsTypeLinks) {
+ this.resolveBases(scope, type);
+ }
+ if(type.construct) {
+ this.resolveSignatureGroup(type.construct, callAndConstructScope, instanceType);
+ }
+ if(type.call) {
+ this.resolveSignatureGroup(type.call, callAndConstructScope, 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 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
+ });
+ };
+ }
+})());
+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, emitFullPathOfSourceMap) {
+ 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);
+ if(emitFullPathOfSourceMap) {
+ if(jsFileName.indexOf("://") == -1) {
+ jsFileName = "file:///" + jsFileName;
+ }
+ this.jsFileName = jsFileName;
+ }
+ 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;
+ }
+ 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;
+ this.emitFullSourceMapPath = settings.emitFullSourceMapPath;
+ }
+ 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.globalThisCapturePrologueEmitted = false;
+ this.extendsPrologueEmitted = 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) {
+ var text = comment.getText();
+ var hadNewLine = false;
+ if(comment.isBlockComment) {
+ if(this.emitState.column == 0) {
+ this.emitIndent();
+ }
+ this.recordSourceMappingStart(comment);
+ this.writeToOutput(text[0]);
+ if(text.length > 1 || comment.endsLine) {
+ for(var i = 1; i < text.length; i++) {
+ this.writeLineToOutput("");
+ this.emitIndent();
+ this.writeToOutput(text[i]);
+ }
+ this.recordSourceMappingEnd(comment);
+ this.writeLineToOutput("");
+ hadNewLine = true;
+ } else {
+ this.recordSourceMappingEnd(comment);
+ }
+ } else {
+ if(this.emitState.column == 0) {
+ this.emitIndent();
+ }
+ this.recordSourceMappingStart(comment);
+ this.writeToOutput(text[0]);
+ this.recordSourceMappingEnd(comment);
+ this.writeLineToOutput("");
+ hadNewLine = true;
+ }
+ if(hadNewLine) {
+ this.emitIndent();
+ } else {
+ this.writeToOutput(" ");
+ }
+ };
+ 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.getConstantValue = function (init) {
+ if(init) {
+ if(init.nodeType === TypeScript.NodeType.NumberLit) {
+ var numLit = init;
+ return numLit.value;
+ } else if(init.nodeType === TypeScript.NodeType.Lsh) {
+ var binop = init;
+ if(binop.operand1.nodeType === TypeScript.NodeType.NumberLit && binop.operand2.nodeType === TypeScript.NodeType.NumberLit) {
+ return (binop.operand1).value << (binop.operand2).value;
+ }
+ } else if(init.nodeType === TypeScript.NodeType.Name) {
+ var ident = init;
+ if(ident.sym !== null && ident.sym.declAST.nodeType === TypeScript.NodeType.VarDecl) {
+ var varDecl = ident.sym.declAST;
+ return this.getConstantValue(varDecl.init);
+ }
+ }
+ }
+ return null;
+ };
+ 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;
+ var value = this.getConstantValue(boundDecl.init);
+ if(value !== null) {
+ this.writeToOutput(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.Signature) || 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.emitOptions.emitFullSourceMapPath));
+ 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.writeToOutput(")(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.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));");
+ } else if(!isExported && temp != EmitContainer.Prog) {
+ this.writeToOutput("}");
+ if(!isWholeFile) {
+ this.recordSourceMappingNameEnd();
+ }
+ this.recordSourceMappingEnd(moduleDecl.endingToken);
+ this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));");
+ } else {
+ this.writeToOutput("}");
+ if(!isWholeFile) {
+ this.recordSourceMappingNameEnd();
+ }
+ this.recordSourceMappingEnd(moduleDecl.endingToken);
+ this.writeToOutput(")();");
+ }
+ this.recordSourceMappingEnd(moduleDecl);
+ this.writeLineToOutput("");
+ 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.Signature)) {
+ 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 isSingleQuotedMod = TypeScript.isSingleQuoted(modPath);
+ 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);
+ if(isSingleQuotedMod) {
+ modPath = TypeScript.changeToSingleQuote(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[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;
+ this.emitParensAndCommentsInPlace(ast, true);
+ if(list.members.length == 0) {
+ this.emitParensAndCommentsInPlace(ast, false);
+ return;
+ }
+ 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.extendsPrologueEmitted) {
+ if(reqInherits) {
+ this.extendsPrologueEmitted = 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.globalThisCapturePrologueEmitted) {
+ if(this.checker.mustCaptureGlobalThis) {
+ this.globalThisCapturePrologueEmitted = 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;
+ 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.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;
+ var memberNames = [];
+ 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;
+ memberNames.push(memberName);
+ } 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, "0");
+ lastValue = memberValue;
+ } else {
+ var nextValue = lastValue.value + 1;
+ memberValue = new TypeScript.NumberLiteral(nextValue, nextValue.toString());
+ 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;
+ } else if(memberValue.nodeType === TypeScript.NodeType.Lsh) {
+ var binop = memberValue;
+ if(binop.operand1.nodeType === TypeScript.NodeType.NumberLit && binop.operand2.nodeType === TypeScript.NodeType.NumberLit) {
+ member.varFlags |= TypeScript.VarFlags.Constant;
+ }
+ } else if(memberValue.nodeType === TypeScript.NodeType.Name) {
+ var nameNode = memberValue;
+ for(var i = 0; i < memberNames.length; i++) {
+ var memberName = memberNames[i];
+ if(memberName.text === nameNode.text) {
+ member.varFlags |= TypeScript.VarFlags.Constant;
+ break;
+ }
+ }
+ }
+ 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(), 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(), 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(), 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(), endingToken);
+ } else {
+ moduleDecl = new TypeScript.ModuleDeclaration(name, moduleBody, this.topVarList(), 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.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;
+ if(bod.limChar > bod.minChar) {
+ 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.limChar = retExpr.limChar;
+ bod.append(retStmt);
+ } else if(this.currentToken.tokenId != TypeScript.TokenID.EndOfFile) {
+ 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.Signature;
+ }
+ 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;
+ opArg.isParenthesized = false;
+ 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);
+ formals.minChar = preProcessedLambdaArgs.minChar;
+ 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.currentToken.tokenId == TypeScript.TokenID.EndOfFile ? this.scanner.pos : 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 && !methodName) {
+ this.currentToken = this.scanner.scan();
+ 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;
+ }
+ }
+ 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);
+ }
+ 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");
+ }
+ if(isLambda && this.currentToken.tokenId != TypeScript.TokenID.EqualsGreaterThan) {
+ this.reportParseError("Expected '=>'");
+ }
+ if(isDecl && !(this.parsingDeclareFile || markedAsAmbient) && !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(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 > 0xffff) {
+ 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(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();
+ var constructorSpan = new TypeScript.ASTSpan();
+ constructorSpan.minChar = this.scanner.startPos;
+ constructorSpan.limChar = this.scanner.pos;
+ 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.constructorSpan = constructorSpan;
+ 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, unnamedAmbientFunctionOk) {
+ 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;
+ }
+ if(!text && unnamedAmbientFunctionOk && !isIndexer) {
+ text = new TypeScript.MissingIdentifier();
+ }
+ var ast = this.parseFncDecl(ers, true, requireSignature, this.currentClassDefinition || this.inInterfaceDecl, 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 || (text.isMissing() && unnamedAmbientFunctionOk && !isIndexer)) {
+ 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:
+ 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.currentToken.tokenId == TypeScript.TokenID.EndOfFile ? this.scanner.pos : 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.currentToken.tokenId == TypeScript.TokenID.EndOfFile ? this.scanner.pos : 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.text);
+ 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.text);
+ 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);
+ 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());
+ if(preComments) {
+ ast.preComments = ast.preComments ? preComments.concat(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.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();
+ 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, true);
+ 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(TypeScript.hasFlag(modifiers, TypeScript.Modifiers.Exported) || 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, false, 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);
+ 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;
+ break;
+ default:
+ temp = this.parseExpr(errorRecoverySet | TypeScript.ErrorRecoverySet.SColon | TypeScript.ErrorRecoverySet.In, TypeScript.OperatorPrecedence.None, false, TypeContext.NoTypes);
+ break;
+ }
+ 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);
+ }
+ caseStmt.colonSpan.minChar = this.scanner.startPos;
+ caseStmt.colonSpan.limChar = this.scanner.pos;
+ 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 = ast.preComments ? preComments.concat(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).bod == null));
+ };
+ 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;
+ 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)) {
+ 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.fname = filename;
+ this.currentUnitIndex = unitIndex;
+ this.currentToken = null;
+ this.needTerminator = false;
+ this.inFunction = false;
+ this.inInterfaceDecl = false;
+ this.inFncDecl = false;
+ this.ambientModule = false;
+ this.ambientClass = false;
+ this.topLevel = true;
+ this.allowImportDeclaration = true;
+ 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.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.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();
+ }
+ 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(), 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 = 0x0A;
+ TypeScript.LexCodeRET = 0x0D;
+ TypeScript.LexCodeLS = 0x2028;
+ TypeScript.LexCodePS = 0x2029;
+ TypeScript.LexCodeTAB = 0x09;
+ TypeScript.LexCodeVTAB = 0x0B;
+ 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,
+ 19893,
+ 19968,
+ 40869,
+ 40960,
+ 42124,
+ 44032,
+ 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,
+ 19893,
+ 19968,
+ 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,
+ 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.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.lastTokenLimChar = function () {
+ if(this.prevSavedToken !== null) {
+ return this.prevSavedToken.limChar;
+ } else {
+ return 0;
+ }
+ };
+ SavedTokens.prototype.lastTokenHadNewline = function () {
+ return this.prevLine != this.startLine;
+ };
+ 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.setText = function (newSrc, textMode) {
+ this.setSourceText(new StringSourceText(newSrc), textMode);
+ };
+ Scanner.prototype.setScanComments = function (value) {
+ this.scanComments = value;
+ };
+ 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseInt(text), text);
+ } else {
+ return null;
+ }
+ }
+ }
+ };
+ Scanner.prototype.scanOctalDigits = function () {
+ var atLeastOneDigit = false;
+ for(; ; ) {
+ if(this.IsOctalDigit(this.ch)) {
+ this.nextChar();
+ atLeastOneDigit = true;
+ } else {
+ if(atLeastOneDigit) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseInt(text), text);
+ } 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ } 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ } 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) {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ } else {
+ if(!atLeastOneDigit) {
+ this.pos = svPos;
+ this.col = svCol;
+ return null;
+ } else {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ }
+ }
+ } else {
+ if(!atLeastOneDigit) {
+ this.pos = svPos;
+ this.col = svCol;
+ return null;
+ } else {
+ var text = this.src.substring(this.startPos, this.pos);
+ return new TypeScript.NumberLiteralToken(parseFloat(text), text);
+ }
+ }
+ }
+ };
+ 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.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(this.src.substring(svPos - 1, this.pos));
+ }
+ }
+ 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 = this.peekChar();
+ this.lexState = LexState.Start;
+ return this.scanStringConstant(TypeScript.LexCodeAPO);
+ } else if(this.lexState == LexState.InMultilineDoubleQuoteString && this.pos < this.len) {
+ this.ch = this.peekChar();
+ this.lexState = LexState.Start;
+ return this.scanStringConstant(TypeScript.LexCodeQUO);
+ }
+ 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 (endCode) {
+ 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.newLine();
+ if(this.mode == LexMode.Line) {
+ this.nextChar();
+ 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)) {
+ var endCode = this.ch;
+ this.nextChar();
+ return this.scanStringConstant(endCode);
+ } 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 0xFF:
+ case 0xFE:
+ case 0xEF:
+ case 0xBB:
+ case 0xBF:
+ 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) && !funcDecl.isAccessor()) {
+ 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);
+ } 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.Signature)) {
+ this.definitionSignature = signature;
+ }
+ };
+ SignatureGroup.prototype.toString = function () {
+ return this.signatures.toString();
+ };
+ SignatureGroup.prototype.toStrings = function (prefix, shortform, scope, getPrettyTypeName, useSignature) {
+ var _this = this;
+ var result = [];
+ var len = this.signatures.length;
+ if(!getPrettyTypeName && len > 1) {
+ shortform = false;
+ }
+ var getMemberNameOfSignature = function (signature) {
+ if(_this.flags & TypeScript.SignatureFlags.IsIndexer) {
+ return signature.toStringHelperEx(shortform, true, scope);
+ } else {
+ return signature.toStringHelperEx(shortform, false, scope, prefix);
+ }
+ };
+ if(useSignature) {
+ result.push(getMemberNameOfSignature(useSignature));
+ } else {
+ for(var i = 0; i < len; i++) {
+ if(len > 1 && this.signatures[i] == this.definitionSignature) {
+ continue;
+ }
+ result.push(getMemberNameOfSignature(this.signatures[i]));
+ if(getPrettyTypeName) {
+ break;
+ }
+ }
+ }
+ if(getPrettyTypeName && len > 1) {
+ var lastMemberName = result[result.length - 1];
+ var overloadString = " (+ " + ((this.definitionSignature != null) ? len - 2 : len - 1) + " overload(s))";
+ lastMemberName.add(TypeScript.MemberName.create(overloadString));
+ }
+ 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.Signature) && TypeScript.hasFlag(this.signatures[j].declAST.fncFlags, TypeScript.FncFlags.Signature)) && 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 (scope) {
+ var scopeSymbol = !scope ? null : scope.container;
+ var scopeRootPath = !scopeSymbol ? [] : scopeSymbol.pathToRoot();
+ var dynamicModuleRoot = null;
+ if(scopeRootPath.length > 0 && scopeRootPath[scopeRootPath.length - 1].declAST && scopeRootPath[scopeRootPath.length - 1].declAST.nodeType == TypeScript.NodeType.ModuleDeclaration && (scopeRootPath[scopeRootPath.length - 1].declAST).isWholeFile()) {
+ dynamicModuleRoot = scopeRootPath[scopeRootPath.length - 1];
+ }
+ var builder = this.getPrettyName(scopeSymbol);
+ var ancestor = this.container;
+ while(ancestor && (ancestor.name != TypeScript.globalId) && ancestor != dynamicModuleRoot) {
+ builder = ancestor.getPrettyName(scopeSymbol) + "." + 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 ? this.field.typeLink.type.getScopedTypeNameEx(scope) : TypeScript.MemberName.create("any"), 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;
+ };
+ ParameterSymbol.prototype.fullName = function () {
+ return this.name;
+ };
+ return ParameterSymbol;
+ })(InferenceSymbol);
+ TypeScript.ParameterSymbol = ParameterSymbol;
+ var VariableSymbol = (function (_super) {
+ __extends(VariableSymbol, _super);
+ function VariableSymbol(name, location, unitIndex, variable) {
+ _super.call(this, name, location, name.length, unitIndex);
+ this.variable = variable;
+ }
+ VariableSymbol.prototype.kind = function () {
+ return TypeScript.SymbolKind.Variable;
+ };
+ VariableSymbol.prototype.writeable = function () {
+ return true;
+ };
+ VariableSymbol.prototype.getType = function () {
+ return this.variable.typeLink.type;
+ };
+ VariableSymbol.prototype.getTypeNameEx = function (scope) {
+ return TypeScript.MemberName.create(this.getType().getScopedTypeNameEx(scope), this.name + ": ", "");
+ };
+ VariableSymbol.prototype.setType = function (type) {
+ this.variable.typeLink.type = type;
+ };
+ VariableSymbol.prototype.isVariable = function () {
+ return true;
+ };
+ return VariableSymbol;
+ })(InferenceSymbol);
+ TypeScript.VariableSymbol = VariableSymbol;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+ var ScopedMembers = (function () {
+ function ScopedMembers(dualMembers) {
+ this.dualMembers = dualMembers;
+ this.allMembers = this.dualMembers;
+ this.publicMembers = this.dualMembers.primaryTable;
+ this.privateMembers = this.dualMembers.secondaryTable;
+ }
+ ScopedMembers.prototype.addPublicMember = function (key, data) {
+ return this.dualMembers.primaryTable.add(key, data);
+ };
+ ScopedMembers.prototype.addPrivateMember = function (key, data) {
+ return this.dualMembers.secondaryTable.add(key, data);
+ };
+ return ScopedMembers;
+ })();
+ TypeScript.ScopedMembers = ScopedMembers;
+ (function (SymbolKind) {
+ SymbolKind._map = [];
+ SymbolKind._map[0] = "None";
+ SymbolKind.None = 0;
+ SymbolKind._map[1] = "Type";
+ SymbolKind.Type = 1;
+ SymbolKind._map[2] = "Field";
+ SymbolKind.Field = 2;
+ SymbolKind._map[3] = "Parameter";
+ SymbolKind.Parameter = 3;
+ SymbolKind._map[4] = "Variable";
+ SymbolKind.Variable = 4;
+ })(TypeScript.SymbolKind || (TypeScript.SymbolKind = {}));
+ var SymbolKind = TypeScript.SymbolKind;
+ var SymbolScope = (function () {
+ function SymbolScope(container) {
+ this.container = container;
+ }
+ SymbolScope.prototype.printLabel = function () {
+ return "base";
+ };
+ SymbolScope.prototype.getAllSymbolNames = function (members) {
+ return [
+ "please",
+ "implement",
+ "in",
+ "derived",
+ "classes"
+ ];
+ };
+ SymbolScope.prototype.getAllTypeSymbolNames = function (members) {
+ return [
+ "please",
+ "implement",
+ "in",
+ "derived",
+ "classes"
+ ];
+ };
+ SymbolScope.prototype.getAllValueSymbolNames = function (members) {
+ return [
+ "please",
+ "implement",
+ "in",
+ "derived",
+ "classes"
+ ];
+ };
+ SymbolScope.prototype.search = function (filter, name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.findLocal = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.find = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.findImplementation = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.findAmbient = function (name, publicOnly, typespace) {
+ return null;
+ };
+ SymbolScope.prototype.print = function (outfile) {
+ if(this.container) {
+ outfile.WriteLine(this.printLabel() + " scope with container: " + this.container.name + "...");
+ } else {
+ outfile.WriteLine(this.printLabel() + " scope...");
+ }
+ };
+ SymbolScope.prototype.enter = function (container, ast, symbol, errorReporter, publicOnly, typespace, ambient) {
+ throw new Error("please implement in derived class");
+ };
+ SymbolScope.prototype.getTable = function () {
+ throw new Error("please implement in derived class");
+ };
+ return SymbolScope;
+ })();
+ TypeScript.SymbolScope = SymbolScope;
+ function symbolCanBeUsed(sym, publicOnly) {
+ return publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true;
+ }
+ var SymbolAggregateScope = (function (_super) {
+ __extends(SymbolAggregateScope, _super);
+ function SymbolAggregateScope(container) {
+ _super.call(this, container);
+ this.valueCache = null;
+ this.valueImplCache = null;
+ this.valueAmbientCache = null;
+ this.typeCache = null;
+ this.typeImplCache = null;
+ this.typeAmbientCache = null;
+ this.parents = null;
+ this.container = container;
+ }
+ SymbolAggregateScope.prototype.printLabel = function () {
+ return "agg";
+ };
+ SymbolAggregateScope.prototype.search = function (filter, name, publicOnly, typespace) {
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var sym = this.parents[i].search(filter, name, publicOnly, typespace);
+ if(sym) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ }
+ return filter.result;
+ };
+ SymbolAggregateScope.prototype.getAllSymbolNames = function (members) {
+ var result = [];
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var parentResult = this.parents[i].getAllSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ }
+ return result;
+ };
+ SymbolAggregateScope.prototype.getAllTypeSymbolNames = function (members) {
+ var result = [];
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var parentResult = this.parents[i].getAllTypeSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ }
+ return result;
+ };
+ SymbolAggregateScope.prototype.getAllValueSymbolNames = function (members) {
+ var result = [];
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ var parentResult = this.parents[i].getAllValueSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ }
+ return result;
+ };
+ SymbolAggregateScope.prototype.print = function (outfile) {
+ _super.prototype.print.call(this, outfile);
+ if(this.parents) {
+ for(var i = 0; i < this.parents.length; i++) {
+ this.parents[i].print(outfile);
+ }
+ }
+ };
+ SymbolAggregateScope.prototype.findImplementation = function (name, publicOnly, typespace) {
+ var sym = null;
+ var i = 0;
+ var implCache = this.valueImplCache;
+ if(typespace) {
+ implCache = this.typeImplCache;
+ }
+ if(implCache && ((sym = implCache.lookup(name)) != null) && (publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true)) {
+ return sym;
+ }
+ if(this.parents) {
+ for(i = 0; i < this.parents.length; i++) {
+ sym = this.parents[i].findImplementation(name, publicOnly, typespace);
+ if(sym) {
+ break;
+ }
+ }
+ }
+ if(implCache) {
+ if(typespace) {
+ this.typeImplCache = new TypeScript.StringHashTable();
+ implCache = this.typeImplCache;
+ } else {
+ this.valueImplCache = new TypeScript.StringHashTable();
+ implCache = this.valueImplCache;
+ }
+ }
+ implCache.add(name, sym);
+ return sym;
+ };
+ SymbolAggregateScope.prototype.find = function (name, publicOnly, typespace) {
+ var sym = null;
+ var i = 0;
+ var cache = this.valueCache;
+ if(typespace) {
+ cache = this.typeCache;
+ }
+ if(cache && ((sym = cache.lookup(name)) != null) && (publicOnly ? !(TypeScript.hasFlag(sym.flags, TypeScript.SymbolFlags.Private) || (sym.declAST && sym.declAST.nodeType == TypeScript.NodeType.FuncDecl && TypeScript.hasFlag((sym.declAST).fncFlags, TypeScript.FncFlags.Private))) : true)) {
+ return sym;
+ }
+ if(this.parents) {
+ for(i = 0; i < this.parents.length; i++) {
+ sym = this.parents[i].find(name, publicOnly, typespace);
+ if(sym) {
+ break;
+ }
+ }
+ }
+ if(cache == null) {
+ if(typespace) {
+ this.typeCache = new TypeScript.StringHashTable();
+ cache = this.typeCache;
+ } else {
+ this.valueCache = new TypeScript.StringHashTable();
+ cache = this.valueCache;
+ }
+ }
+ cache.add(name, sym);
+ return sym;
+ };
+ SymbolAggregateScope.prototype.findAmbient = function (name, publicOnly, typespace) {
+ var sym = null;
+ var i = 0;
+ var cache = this.valueAmbientCache;
+ if(typespace) {
+ cache = this.typeAmbientCache;
+ }
+ if(cache && ((sym = cache.lookup(name)) != null)) {
+ return sym;
+ }
+ if(this.parents) {
+ for(i = 0; i < this.parents.length; i++) {
+ sym = this.parents[i].findAmbient(name, publicOnly, typespace);
+ if(sym) {
+ break;
+ }
+ }
+ }
+ if(cache == null) {
+ if(typespace) {
+ this.typeAmbientCache = new TypeScript.StringHashTable();
+ cache = this.typeAmbientCache;
+ } else {
+ this.valueAmbientCache = new TypeScript.StringHashTable();
+ cache = this.valueAmbientCache;
+ }
+ }
+ cache.add(name, sym);
+ return sym;
+ };
+ SymbolAggregateScope.prototype.addParentScope = function (parent) {
+ if(this.parents == null) {
+ this.parents = new Array();
+ }
+ this.parents[this.parents.length] = parent;
+ };
+ return SymbolAggregateScope;
+ })(SymbolScope);
+ TypeScript.SymbolAggregateScope = SymbolAggregateScope;
+ var SymbolTableScope = (function (_super) {
+ __extends(SymbolTableScope, _super);
+ function SymbolTableScope(valueMembers, ambientValueMembers, enclosedTypes, ambientEnclosedTypes, container) {
+ _super.call(this, container);
+ this.valueMembers = valueMembers;
+ this.ambientValueMembers = ambientValueMembers;
+ this.enclosedTypes = enclosedTypes;
+ this.ambientEnclosedTypes = ambientEnclosedTypes;
+ this.container = container;
+ }
+ SymbolTableScope.prototype.printLabel = function () {
+ return "table";
+ };
+ SymbolTableScope.prototype.getAllSymbolNames = function (members) {
+ var result = this.getAllTypeSymbolNames(members);
+ return result.concat(this.getAllValueSymbolNames(members));
+ };
+ SymbolTableScope.prototype.getAllTypeSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientEnclosedTypes) {
+ result = result.concat(this.ambientEnclosedTypes.allMembers.getAllKeys());
+ }
+ if(this.enclosedTypes) {
+ result = result.concat(this.enclosedTypes.allMembers.getAllKeys());
+ }
+ return result;
+ };
+ SymbolTableScope.prototype.getAllValueSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientValueMembers) {
+ result = result.concat(this.ambientValueMembers.allMembers.getAllKeys());
+ }
+ if(this.valueMembers) {
+ result = result.concat(this.valueMembers.allMembers.getAllKeys());
+ }
+ return result;
+ };
+ SymbolTableScope.prototype.search = function (filter, name, publicOnly, typespace) {
+ var sym = this.find(name, publicOnly, typespace);
+ filter.update(sym);
+ return filter.result;
+ };
+ SymbolTableScope.prototype.find = function (name, publicOnly, typespace) {
+ var table = null;
+ var ambientTable = null;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ } else {
+ table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ }
+ if(ambientTable) {
+ var s = ambientTable.lookup(name);
+ if(s) {
+ return s;
+ }
+ }
+ if(table) {
+ var s = table.lookup(name);
+ if(s) {
+ return s;
+ }
+ }
+ return null;
+ };
+ SymbolTableScope.prototype.findAmbient = function (name, publicOnly, typespace) {
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable) {
+ var s = ambientTable.lookup(name);
+ if(s) {
+ return s;
+ }
+ }
+ return null;
+ };
+ SymbolTableScope.prototype.print = function (outfile) {
+ _super.prototype.print.call(this, outfile);
+ if(this.ambientValueMembers) {
+ this.ambientValueMembers.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.valueMembers) {
+ this.valueMembers.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.ambientEnclosedTypes) {
+ this.ambientEnclosedTypes.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.enclosedTypes) {
+ this.enclosedTypes.allMembers.map(function (key, sym, context) {
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ };
+ SymbolTableScope.prototype.findImplementation = function (name, publicOnly, typespace) {
+ var sym = this.find(name, publicOnly, typespace);
+ if(sym) {
+ if(sym.kind() == SymbolKind.Type) {
+ var typeSym = sym;
+ if(!typeSym.type.hasImplementation()) {
+ sym = null;
+ }
+ } else if(sym.container) {
+ if(sym.container.kind() == SymbolKind.Type) {
+ var ctypeSym = sym.container;
+ if(!ctypeSym.type.hasImplementation()) {
+ sym = null;
+ }
+ }
+ }
+ }
+ return sym;
+ };
+ SymbolTableScope.prototype.getTable = function () {
+ return this.valueMembers.publicMembers;
+ };
+ return SymbolTableScope;
+ })(SymbolScope);
+ TypeScript.SymbolTableScope = SymbolTableScope;
+ var SymbolScopeBuilder = (function (_super) {
+ __extends(SymbolScopeBuilder, _super);
+ function SymbolScopeBuilder(valueMembers, ambientValueMembers, enclosedTypes, ambientEnclosedTypes, parent, container) {
+ _super.call(this, container);
+ this.valueMembers = valueMembers;
+ this.ambientValueMembers = ambientValueMembers;
+ this.enclosedTypes = enclosedTypes;
+ this.ambientEnclosedTypes = ambientEnclosedTypes;
+ this.parent = parent;
+ this.container = container;
+ }
+ SymbolScopeBuilder.prototype.printLabel = function () {
+ return "builder";
+ };
+ SymbolScopeBuilder.prototype.getAllSymbolNames = function (members) {
+ var result = this.getAllTypeSymbolNames(members);
+ return result.concat(this.getAllValueSymbolNames(members));
+ };
+ SymbolScopeBuilder.prototype.getAllTypeSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientEnclosedTypes) {
+ result = result.concat(this.ambientEnclosedTypes.allMembers.getAllKeys());
+ }
+ if(this.enclosedTypes) {
+ result = result.concat(this.enclosedTypes.allMembers.getAllKeys());
+ }
+ if(!members && this.parent) {
+ var parentResult = this.parent.getAllTypeSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ return result;
+ };
+ SymbolScopeBuilder.prototype.getAllValueSymbolNames = function (members) {
+ var result = [];
+ if(this.ambientValueMembers) {
+ result = result.concat(this.ambientValueMembers.allMembers.getAllKeys());
+ }
+ if(this.valueMembers) {
+ result = result.concat(this.valueMembers.allMembers.getAllKeys());
+ }
+ if(!members && this.parent) {
+ var parentResult = this.parent.getAllValueSymbolNames(members);
+ if(parentResult) {
+ result = result.concat(parentResult);
+ }
+ }
+ return result;
+ };
+ SymbolScopeBuilder.prototype.search = function (filter, name, publicOnly, typespace) {
+ var sym = null;
+ var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable) {
+ if((sym = ambientTable.lookup(name)) != null) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ if(table) {
+ if((sym = table.lookup(name)) != null) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ if(this.parent) {
+ sym = this.parent.search(filter, name, publicOnly, typespace);
+ if(sym) {
+ if(filter.update(sym)) {
+ return sym;
+ }
+ }
+ }
+ return filter.result;
+ };
+ SymbolScopeBuilder.prototype.print = function (outfile) {
+ _super.prototype.print.call(this, outfile);
+ if(this.ambientValueMembers) {
+ this.ambientValueMembers.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.valueMembers) {
+ this.valueMembers.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.ambientEnclosedTypes) {
+ this.ambientEnclosedTypes.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.enclosedTypes) {
+ this.enclosedTypes.allMembers.map(function (key, s, context) {
+ var sym = s;
+ outfile.WriteLine(" " + key);
+ }, null);
+ }
+ if(this.parent) {
+ this.parent.print(outfile);
+ }
+ };
+ SymbolScopeBuilder.prototype.find = function (name, publicOnly, typespace) {
+ var sym = null;
+ var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable && ((sym = ambientTable.lookup(name)) != null)) {
+ return sym;
+ }
+ if(table && ((sym = table.lookup(name)) != null)) {
+ return sym;
+ }
+ if(this.parent) {
+ return this.parent.find(name, publicOnly, typespace);
+ }
+ return null;
+ };
+ SymbolScopeBuilder.prototype.findAmbient = function (name, publicOnly, typespace) {
+ var sym = null;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(ambientTable && ((sym = ambientTable.lookup(name)) != null)) {
+ return sym;
+ }
+ if(this.parent) {
+ return this.parent.findAmbient(name, publicOnly, typespace);
+ }
+ return null;
+ };
+ SymbolScopeBuilder.prototype.findLocal = function (name, publicOnly, typespace) {
+ var sym = null;
+ var table = (this.valueMembers == null) ? null : publicOnly ? this.valueMembers.publicMembers : this.valueMembers.allMembers;
+ var ambientTable = (this.ambientValueMembers == null) ? null : publicOnly ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.allMembers;
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : publicOnly ? this.enclosedTypes.publicMembers : this.enclosedTypes.allMembers;
+ ambientTable = (this.ambientEnclosedTypes == null) ? null : publicOnly ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.allMembers;
+ }
+ if(table) {
+ if((sym = table.lookup(name)) != null) {
+ if(sym) {
+ return sym;
+ }
+ }
+ }
+ if(ambientTable) {
+ if((sym = ambientTable.lookup(name)) != null) {
+ if(sym) {
+ return sym;
+ }
+ }
+ }
+ return null;
+ };
+ SymbolScopeBuilder.prototype.enter = function (container, ast, symbol, errorReporter, insertAsPublic, typespace, ambient) {
+ var table = null;
+ if(ambient) {
+ if(typespace) {
+ table = (this.ambientEnclosedTypes == null) ? null : insertAsPublic ? this.ambientEnclosedTypes.publicMembers : this.ambientEnclosedTypes.privateMembers;
+ } else {
+ table = (this.ambientValueMembers == null) ? null : insertAsPublic ? this.ambientValueMembers.publicMembers : this.ambientValueMembers.privateMembers;
+ }
+ } else {
+ if(typespace) {
+ table = (this.enclosedTypes == null) ? null : insertAsPublic ? this.enclosedTypes.publicMembers : this.enclosedTypes.privateMembers;
+ } else {
+ table = (this.valueMembers == null) ? null : insertAsPublic ? this.valueMembers.publicMembers : this.valueMembers.privateMembers;
+ }
+ }
+ if(table) {
+ if(!table.add(symbol.name, symbol)) {
+ errorReporter.duplicateIdentifier(ast, symbol.name);
+ }
+ } else {
+ TypeScript.CompilerDiagnostics.Alert("YYYYY");
+ }
+ symbol.container = container;
+ };
+ SymbolScopeBuilder.prototype.getTable = function () {
+ return this.valueMembers.allMembers;
+ };
+ return SymbolScopeBuilder;
+ })(SymbolScope);
+ TypeScript.SymbolScopeBuilder = SymbolScopeBuilder;
+ var FilteredSymbolScope = (function (_super) {
+ __extends(FilteredSymbolScope, _super);
+ function FilteredSymbolScope(scope, container, filter) {
+ _super.call(this, container);
+ this.scope = scope;
+ this.filter = filter;
+ }
+ FilteredSymbolScope.prototype.print = function (outfile) {
+ this.scope.print(outfile);
+ };
+ FilteredSymbolScope.prototype.find = function (name, publicOnly, typespace) {
+ this.filter.reset();
+ return this.scope.search(this.filter, name, publicOnly, typespace);
+ };
+ FilteredSymbolScope.prototype.findLocal = function (name, publicOnly, typespace) {
+ return this.scope.findLocal(name, publicOnly, typespace);
+ };
+ return FilteredSymbolScope;
+ })(SymbolScope);
+ TypeScript.FilteredSymbolScope = FilteredSymbolScope;
+ var FilteredSymbolScopeBuilder = (function (_super) {
+ __extends(FilteredSymbolScopeBuilder, _super);
+ function FilteredSymbolScopeBuilder(valueMembers, parent, container, filter) {
+ _super.call(this, valueMembers, null, null, null, parent, container);
+ this.filter = filter;
+ }
+ FilteredSymbolScopeBuilder.prototype.findLocal = function (name, publicOnly, typespace) {
+ var sym = _super.prototype.findLocal.call(this, name, publicOnly, typespace);
+ if(sym) {
+ if(!this.filter(sym)) {
+ return null;
+ }
+ }
+ return sym;
+ };
+ FilteredSymbolScopeBuilder.prototype.search = function (filter, name, publicOnly, typespace) {
+ throw new Error("please implement");
+ };
+ FilteredSymbolScopeBuilder.prototype.find = function (name, publicOnly, typespace) {
+ var sym = _super.prototype.findLocal.call(this, name, publicOnly, typespace);
+ if(sym) {
+ if(!this.filter(sym)) {
+ return null;
+ }
+ }
+ return _super.prototype.find.call(this, name, publicOnly, typespace);
+ };
+ return FilteredSymbolScopeBuilder;
+ })(SymbolScopeBuilder);
+ TypeScript.FilteredSymbolScopeBuilder = FilteredSymbolScopeBuilder;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+ (function (TokenID) {
+ TokenID._map = [];
+ TokenID._map[0] = "Any";
+ TokenID.Any = 0;
+ TokenID._map[1] = "Bool";
+ TokenID.Bool = 1;
+ TokenID._map[2] = "Break";
+ TokenID.Break = 2;
+ TokenID._map[3] = "Case";
+ TokenID.Case = 3;
+ TokenID._map[4] = "Catch";
+ TokenID.Catch = 4;
+ TokenID._map[5] = "Class";
+ TokenID.Class = 5;
+ TokenID._map[6] = "Const";
+ TokenID.Const = 6;
+ TokenID._map[7] = "Continue";
+ TokenID.Continue = 7;
+ TokenID._map[8] = "Debugger";
+ TokenID.Debugger = 8;
+ TokenID._map[9] = "Default";
+ TokenID.Default = 9;
+ TokenID._map[10] = "Delete";
+ TokenID.Delete = 10;
+ TokenID._map[11] = "Do";
+ TokenID.Do = 11;
+ TokenID._map[12] = "Else";
+ TokenID.Else = 12;
+ TokenID._map[13] = "Enum";
+ TokenID.Enum = 13;
+ TokenID._map[14] = "Export";
+ TokenID.Export = 14;
+ TokenID._map[15] = "Extends";
+ TokenID.Extends = 15;
+ TokenID._map[16] = "Declare";
+ TokenID.Declare = 16;
+ TokenID._map[17] = "False";
+ TokenID.False = 17;
+ TokenID._map[18] = "Finally";
+ TokenID.Finally = 18;
+ TokenID._map[19] = "For";
+ TokenID.For = 19;
+ TokenID._map[20] = "Function";
+ TokenID.Function = 20;
+ TokenID._map[21] = "Constructor";
+ TokenID.Constructor = 21;
+ TokenID._map[22] = "Get";
+ TokenID.Get = 22;
+ TokenID._map[23] = "If";
+ TokenID.If = 23;
+ TokenID._map[24] = "Implements";
+ TokenID.Implements = 24;
+ TokenID._map[25] = "Import";
+ TokenID.Import = 25;
+ TokenID._map[26] = "In";
+ TokenID.In = 26;
+ TokenID._map[27] = "InstanceOf";
+ TokenID.InstanceOf = 27;
+ TokenID._map[28] = "Interface";
+ TokenID.Interface = 28;
+ TokenID._map[29] = "Let";
+ TokenID.Let = 29;
+ TokenID._map[30] = "Module";
+ TokenID.Module = 30;
+ TokenID._map[31] = "New";
+ TokenID.New = 31;
+ TokenID._map[32] = "Number";
+ TokenID.Number = 32;
+ TokenID._map[33] = "Null";
+ TokenID.Null = 33;
+ TokenID._map[34] = "Package";
+ TokenID.Package = 34;
+ TokenID._map[35] = "Private";
+ TokenID.Private = 35;
+ TokenID._map[36] = "Protected";
+ TokenID.Protected = 36;
+ TokenID._map[37] = "Public";
+ TokenID.Public = 37;
+ TokenID._map[38] = "Return";
+ TokenID.Return = 38;
+ TokenID._map[39] = "Set";
+ TokenID.Set = 39;
+ TokenID._map[40] = "Static";
+ TokenID.Static = 40;
+ TokenID._map[41] = "String";
+ TokenID.String = 41;
+ TokenID._map[42] = "Super";
+ TokenID.Super = 42;
+ TokenID._map[43] = "Switch";
+ TokenID.Switch = 43;
+ TokenID._map[44] = "This";
+ TokenID.This = 44;
+ TokenID._map[45] = "Throw";
+ TokenID.Throw = 45;
+ TokenID._map[46] = "True";
+ TokenID.True = 46;
+ TokenID._map[47] = "Try";
+ TokenID.Try = 47;
+ TokenID._map[48] = "TypeOf";
+ TokenID.TypeOf = 48;
+ TokenID._map[49] = "Var";
+ TokenID.Var = 49;
+ TokenID._map[50] = "Void";
+ TokenID.Void = 50;
+ TokenID._map[51] = "With";
+ TokenID.With = 51;
+ TokenID._map[52] = "While";
+ TokenID.While = 52;
+ TokenID._map[53] = "Yield";
+ TokenID.Yield = 53;
+ TokenID._map[54] = "Semicolon";
+ TokenID.Semicolon = 54;
+ TokenID._map[55] = "OpenParen";
+ TokenID.OpenParen = 55;
+ TokenID._map[56] = "CloseParen";
+ TokenID.CloseParen = 56;
+ TokenID._map[57] = "OpenBracket";
+ TokenID.OpenBracket = 57;
+ TokenID._map[58] = "CloseBracket";
+ TokenID.CloseBracket = 58;
+ TokenID._map[59] = "OpenBrace";
+ TokenID.OpenBrace = 59;
+ TokenID._map[60] = "CloseBrace";
+ TokenID.CloseBrace = 60;
+ TokenID._map[61] = "Comma";
+ TokenID.Comma = 61;
+ TokenID._map[62] = "Equals";
+ TokenID.Equals = 62;
+ TokenID._map[63] = "PlusEquals";
+ TokenID.PlusEquals = 63;
+ TokenID._map[64] = "MinusEquals";
+ TokenID.MinusEquals = 64;
+ TokenID._map[65] = "AsteriskEquals";
+ TokenID.AsteriskEquals = 65;
+ TokenID._map[66] = "SlashEquals";
+ TokenID.SlashEquals = 66;
+ TokenID._map[67] = "PercentEquals";
+ TokenID.PercentEquals = 67;
+ TokenID._map[68] = "AmpersandEquals";
+ TokenID.AmpersandEquals = 68;
+ TokenID._map[69] = "CaretEquals";
+ TokenID.CaretEquals = 69;
+ TokenID._map[70] = "BarEquals";
+ TokenID.BarEquals = 70;
+ TokenID._map[71] = "LessThanLessThanEquals";
+ TokenID.LessThanLessThanEquals = 71;
+ TokenID._map[72] = "GreaterThanGreaterThanEquals";
+ TokenID.GreaterThanGreaterThanEquals = 72;
+ TokenID._map[73] = "GreaterThanGreaterThanGreaterThanEquals";
+ TokenID.GreaterThanGreaterThanGreaterThanEquals = 73;
+ TokenID._map[74] = "Question";
+ TokenID.Question = 74;
+ TokenID._map[75] = "Colon";
+ TokenID.Colon = 75;
+ TokenID._map[76] = "BarBar";
+ TokenID.BarBar = 76;
+ TokenID._map[77] = "AmpersandAmpersand";
+ TokenID.AmpersandAmpersand = 77;
+ TokenID._map[78] = "Bar";
+ TokenID.Bar = 78;
+ TokenID._map[79] = "Caret";
+ TokenID.Caret = 79;
+ TokenID._map[80] = "And";
+ TokenID.And = 80;
+ TokenID._map[81] = "EqualsEquals";
+ TokenID.EqualsEquals = 81;
+ TokenID._map[82] = "ExclamationEquals";
+ TokenID.ExclamationEquals = 82;
+ TokenID._map[83] = "EqualsEqualsEquals";
+ TokenID.EqualsEqualsEquals = 83;
+ TokenID._map[84] = "ExclamationEqualsEquals";
+ TokenID.ExclamationEqualsEquals = 84;
+ TokenID._map[85] = "LessThan";
+ TokenID.LessThan = 85;
+ TokenID._map[86] = "LessThanEquals";
+ TokenID.LessThanEquals = 86;
+ TokenID._map[87] = "GreaterThan";
+ TokenID.GreaterThan = 87;
+ TokenID._map[88] = "GreaterThanEquals";
+ TokenID.GreaterThanEquals = 88;
+ TokenID._map[89] = "LessThanLessThan";
+ TokenID.LessThanLessThan = 89;
+ TokenID._map[90] = "GreaterThanGreaterThan";
+ TokenID.GreaterThanGreaterThan = 90;
+ TokenID._map[91] = "GreaterThanGreaterThanGreaterThan";
+ TokenID.GreaterThanGreaterThanGreaterThan = 91;
+ TokenID._map[92] = "Plus";
+ TokenID.Plus = 92;
+ TokenID._map[93] = "Minus";
+ TokenID.Minus = 93;
+ TokenID._map[94] = "Asterisk";
+ TokenID.Asterisk = 94;
+ TokenID._map[95] = "Slash";
+ TokenID.Slash = 95;
+ TokenID._map[96] = "Percent";
+ TokenID.Percent = 96;
+ TokenID._map[97] = "Tilde";
+ TokenID.Tilde = 97;
+ TokenID._map[98] = "Exclamation";
+ TokenID.Exclamation = 98;
+ TokenID._map[99] = "PlusPlus";
+ TokenID.PlusPlus = 99;
+ TokenID._map[100] = "MinusMinus";
+ TokenID.MinusMinus = 100;
+ TokenID._map[101] = "Dot";
+ TokenID.Dot = 101;
+ TokenID._map[102] = "DotDotDot";
+ TokenID.DotDotDot = 102;
+ TokenID._map[103] = "Error";
+ TokenID.Error = 103;
+ TokenID._map[104] = "EndOfFile";
+ TokenID.EndOfFile = 104;
+ TokenID._map[105] = "EqualsGreaterThan";
+ TokenID.EqualsGreaterThan = 105;
+ TokenID._map[106] = "Identifier";
+ TokenID.Identifier = 106;
+ TokenID._map[107] = "StringLiteral";
+ TokenID.StringLiteral = 107;
+ TokenID._map[108] = "RegularExpressionLiteral";
+ TokenID.RegularExpressionLiteral = 108;
+ TokenID._map[109] = "NumberLiteral";
+ TokenID.NumberLiteral = 109;
+ TokenID._map[110] = "Whitespace";
+ TokenID.Whitespace = 110;
+ TokenID._map[111] = "Comment";
+ TokenID.Comment = 111;
+ TokenID._map[112] = "Lim";
+ TokenID.Lim = 112;
+ TokenID.LimFixed = TokenID.EqualsGreaterThan;
+ TokenID.LimKeyword = TokenID.Yield;
+ })(TypeScript.TokenID || (TypeScript.TokenID = {}));
+ var TokenID = TypeScript.TokenID;
+ TypeScript.tokenTable = new Array();
+ TypeScript.nodeTypeTable = new Array();
+ TypeScript.nodeTypeToTokTable = new Array();
+ TypeScript.noRegexTable = new Array();
+ TypeScript.noRegexTable[TokenID.Identifier] = true;
+ TypeScript.noRegexTable[TokenID.StringLiteral] = true;
+ TypeScript.noRegexTable[TokenID.NumberLiteral] = true;
+ TypeScript.noRegexTable[TokenID.RegularExpressionLiteral] = true;
+ TypeScript.noRegexTable[TokenID.This] = true;
+ TypeScript.noRegexTable[TokenID.PlusPlus] = true;
+ TypeScript.noRegexTable[TokenID.MinusMinus] = true;
+ TypeScript.noRegexTable[TokenID.CloseParen] = true;
+ TypeScript.noRegexTable[TokenID.CloseBracket] = true;
+ TypeScript.noRegexTable[TokenID.CloseBrace] = true;
+ TypeScript.noRegexTable[TokenID.True] = true;
+ TypeScript.noRegexTable[TokenID.False] = true;
+ (function (OperatorPrecedence) {
+ OperatorPrecedence._map = [];
+ OperatorPrecedence._map[0] = "None";
+ OperatorPrecedence.None = 0;
+ OperatorPrecedence._map[1] = "Comma";
+ OperatorPrecedence.Comma = 1;
+ OperatorPrecedence._map[2] = "Assignment";
+ OperatorPrecedence.Assignment = 2;
+ OperatorPrecedence._map[3] = "Conditional";
+ OperatorPrecedence.Conditional = 3;
+ OperatorPrecedence._map[4] = "LogicalOr";
+ OperatorPrecedence.LogicalOr = 4;
+ OperatorPrecedence._map[5] = "LogicalAnd";
+ OperatorPrecedence.LogicalAnd = 5;
+ OperatorPrecedence._map[6] = "BitwiseOr";
+ OperatorPrecedence.BitwiseOr = 6;
+ OperatorPrecedence._map[7] = "BitwiseExclusiveOr";
+ OperatorPrecedence.BitwiseExclusiveOr = 7;
+ OperatorPrecedence._map[8] = "BitwiseAnd";
+ OperatorPrecedence.BitwiseAnd = 8;
+ OperatorPrecedence._map[9] = "Equality";
+ OperatorPrecedence.Equality = 9;
+ OperatorPrecedence._map[10] = "Relational";
+ OperatorPrecedence.Relational = 10;
+ OperatorPrecedence._map[11] = "Shift";
+ OperatorPrecedence.Shift = 11;
+ OperatorPrecedence._map[12] = "Additive";
+ OperatorPrecedence.Additive = 12;
+ OperatorPrecedence._map[13] = "Multiplicative";
+ OperatorPrecedence.Multiplicative = 13;
+ OperatorPrecedence._map[14] = "Unary";
+ OperatorPrecedence.Unary = 14;
+ OperatorPrecedence._map[15] = "Lim";
+ OperatorPrecedence.Lim = 15;
+ })(TypeScript.OperatorPrecedence || (TypeScript.OperatorPrecedence = {}));
+ var OperatorPrecedence = TypeScript.OperatorPrecedence;
+ (function (Reservation) {
+ Reservation._map = [];
+ Reservation.None = 0;
+ Reservation.Javascript = 1;
+ Reservation.JavascriptFuture = 2;
+ Reservation.TypeScript = 4;
+ Reservation.JavascriptFutureStrict = 8;
+ Reservation.TypeScriptAndJS = Reservation.Javascript | Reservation.TypeScript;
+ Reservation.TypeScriptAndJSFuture = Reservation.JavascriptFuture | Reservation.TypeScript;
+ Reservation.TypeScriptAndJSFutureStrict = Reservation.JavascriptFutureStrict | Reservation.TypeScript;
+ })(TypeScript.Reservation || (TypeScript.Reservation = {}));
+ var Reservation = TypeScript.Reservation;
+ var TokenInfo = (function () {
+ function TokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers) {
+ this.tokenId = tokenId;
+ this.reservation = reservation;
+ this.binopPrecedence = binopPrecedence;
+ this.binopNodeType = binopNodeType;
+ this.unopPrecedence = unopPrecedence;
+ this.unopNodeType = unopNodeType;
+ this.text = text;
+ this.ers = ers;
+ }
+ return TokenInfo;
+ })();
+ TypeScript.TokenInfo = TokenInfo;
+ function setTokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers) {
+ if(tokenId !== undefined) {
+ TypeScript.tokenTable[tokenId] = new TokenInfo(tokenId, reservation, binopPrecedence, binopNodeType, unopPrecedence, unopNodeType, text, ers);
+ if(binopNodeType != TypeScript.NodeType.None) {
+ TypeScript.nodeTypeTable[binopNodeType] = text;
+ TypeScript.nodeTypeToTokTable[binopNodeType] = tokenId;
+ }
+ if(unopNodeType != TypeScript.NodeType.None) {
+ TypeScript.nodeTypeTable[unopNodeType] = text;
+ }
+ }
+ }
+ setTokenInfo(TokenID.Any, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "any", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Bool, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "bool", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Break, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "break", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Case, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "case", TypeScript.ErrorRecoverySet.SCase);
+ setTokenInfo(TokenID.Catch, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "catch", TypeScript.ErrorRecoverySet.Catch);
+ setTokenInfo(TokenID.Class, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "class", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Const, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "const", TypeScript.ErrorRecoverySet.Var);
+ setTokenInfo(TokenID.Continue, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "continue", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Debugger, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.Debugger, "debugger", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Default, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "default", TypeScript.ErrorRecoverySet.SCase);
+ setTokenInfo(TokenID.Delete, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Delete, "delete", TypeScript.ErrorRecoverySet.Prefix);
+ setTokenInfo(TokenID.Do, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "do", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Else, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "else", TypeScript.ErrorRecoverySet.Else);
+ setTokenInfo(TokenID.Enum, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "enum", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Export, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "export", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Extends, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "extends", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Declare, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "declare", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.False, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "false", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Finally, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "finally", TypeScript.ErrorRecoverySet.Catch);
+ setTokenInfo(TokenID.For, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "for", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Function, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "function", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.Constructor, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "constructor", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.Get, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "get", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.Set, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "set", TypeScript.ErrorRecoverySet.Func);
+ setTokenInfo(TokenID.If, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "if", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Implements, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "implements", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Import, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "import", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.In, Reservation.TypeScriptAndJS, OperatorPrecedence.Relational, TypeScript.NodeType.In, OperatorPrecedence.None, TypeScript.NodeType.None, "in", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.InstanceOf, Reservation.TypeScriptAndJS, OperatorPrecedence.Relational, TypeScript.NodeType.InstOf, OperatorPrecedence.None, TypeScript.NodeType.None, "instanceof", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Interface, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "interface", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Let, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "let", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Module, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "module", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.New, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "new", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.Number, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "number", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Null, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "null", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Package, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "package", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Private, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "private", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Protected, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "protected", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Public, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "public", TypeScript.ErrorRecoverySet.TypeScriptS);
+ setTokenInfo(TokenID.Return, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "return", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.Static, Reservation.TypeScriptAndJSFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "static", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.String, Reservation.TypeScript, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "string", TypeScript.ErrorRecoverySet.PrimType);
+ setTokenInfo(TokenID.Super, Reservation.TypeScriptAndJSFuture, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "super", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Switch, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "switch", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.This, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "this", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Throw, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "throw", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.True, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "true", TypeScript.ErrorRecoverySet.RLit);
+ setTokenInfo(TokenID.Try, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "try", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.TypeOf, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Typeof, "typeof", TypeScript.ErrorRecoverySet.Prefix);
+ setTokenInfo(TokenID.Var, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "var", TypeScript.ErrorRecoverySet.Var);
+ setTokenInfo(TokenID.Void, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Void, "void", TypeScript.ErrorRecoverySet.Prefix);
+ setTokenInfo(TokenID.With, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.With, "with", TypeScript.ErrorRecoverySet.Stmt);
+ setTokenInfo(TokenID.While, Reservation.TypeScriptAndJS, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "while", TypeScript.ErrorRecoverySet.While);
+ setTokenInfo(TokenID.Yield, Reservation.JavascriptFutureStrict, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "yield", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Identifier, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "identifier", TypeScript.ErrorRecoverySet.ID);
+ setTokenInfo(TokenID.NumberLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "numberLiteral", TypeScript.ErrorRecoverySet.Literal);
+ setTokenInfo(TokenID.RegularExpressionLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "regex", TypeScript.ErrorRecoverySet.RegExp);
+ setTokenInfo(TokenID.StringLiteral, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "qstring", TypeScript.ErrorRecoverySet.Literal);
+ setTokenInfo(TokenID.Semicolon, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ";", TypeScript.ErrorRecoverySet.SColon);
+ setTokenInfo(TokenID.CloseParen, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ")", TypeScript.ErrorRecoverySet.RParen);
+ setTokenInfo(TokenID.CloseBracket, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "]", TypeScript.ErrorRecoverySet.RBrack);
+ setTokenInfo(TokenID.OpenBrace, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "{", TypeScript.ErrorRecoverySet.LCurly);
+ setTokenInfo(TokenID.CloseBrace, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "}", TypeScript.ErrorRecoverySet.RCurly);
+ setTokenInfo(TokenID.DotDotDot, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "...", TypeScript.ErrorRecoverySet.None);
+ setTokenInfo(TokenID.Comma, Reservation.None, OperatorPrecedence.Comma, TypeScript.NodeType.Comma, OperatorPrecedence.None, TypeScript.NodeType.None, ",", TypeScript.ErrorRecoverySet.Comma);
+ setTokenInfo(TokenID.Equals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.Asg, OperatorPrecedence.None, TypeScript.NodeType.None, "=", TypeScript.ErrorRecoverySet.Asg);
+ setTokenInfo(TokenID.PlusEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgAdd, OperatorPrecedence.None, TypeScript.NodeType.None, "+=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.MinusEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgSub, OperatorPrecedence.None, TypeScript.NodeType.None, "-=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.AsteriskEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgMul, OperatorPrecedence.None, TypeScript.NodeType.None, "*=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.SlashEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgDiv, OperatorPrecedence.None, TypeScript.NodeType.None, "/=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.PercentEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgMod, OperatorPrecedence.None, TypeScript.NodeType.None, "%=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.AmpersandEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgAnd, OperatorPrecedence.None, TypeScript.NodeType.None, "&=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.CaretEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgXor, OperatorPrecedence.None, TypeScript.NodeType.None, "^=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.BarEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgOr, OperatorPrecedence.None, TypeScript.NodeType.None, "|=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThanLessThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgLsh, OperatorPrecedence.None, TypeScript.NodeType.None, "<<=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgRsh, OperatorPrecedence.None, TypeScript.NodeType.None, ">>=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThanGreaterThanEquals, Reservation.None, OperatorPrecedence.Assignment, TypeScript.NodeType.AsgRs2, OperatorPrecedence.None, TypeScript.NodeType.None, ">>>=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Question, Reservation.None, OperatorPrecedence.Conditional, TypeScript.NodeType.ConditionalExpression, OperatorPrecedence.None, TypeScript.NodeType.None, "?", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Colon, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ":", TypeScript.ErrorRecoverySet.Colon);
+ setTokenInfo(TokenID.BarBar, Reservation.None, OperatorPrecedence.LogicalOr, TypeScript.NodeType.LogOr, OperatorPrecedence.None, TypeScript.NodeType.None, "||", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.AmpersandAmpersand, Reservation.None, OperatorPrecedence.LogicalAnd, TypeScript.NodeType.LogAnd, OperatorPrecedence.None, TypeScript.NodeType.None, "&&", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Bar, Reservation.None, OperatorPrecedence.BitwiseOr, TypeScript.NodeType.Or, OperatorPrecedence.None, TypeScript.NodeType.None, "|", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Caret, Reservation.None, OperatorPrecedence.BitwiseExclusiveOr, TypeScript.NodeType.Xor, OperatorPrecedence.None, TypeScript.NodeType.None, "^", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.And, Reservation.None, OperatorPrecedence.BitwiseAnd, TypeScript.NodeType.And, OperatorPrecedence.None, TypeScript.NodeType.None, "&", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.EqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Eq, OperatorPrecedence.None, TypeScript.NodeType.None, "==", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.ExclamationEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Ne, OperatorPrecedence.None, TypeScript.NodeType.None, "!=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.EqualsEqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.Eqv, OperatorPrecedence.None, TypeScript.NodeType.None, "===", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.ExclamationEqualsEquals, Reservation.None, OperatorPrecedence.Equality, TypeScript.NodeType.NEqv, OperatorPrecedence.None, TypeScript.NodeType.None, "!==", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThan, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Lt, OperatorPrecedence.None, TypeScript.NodeType.None, "<", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThanEquals, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Le, OperatorPrecedence.None, TypeScript.NodeType.None, "<=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThan, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Gt, OperatorPrecedence.None, TypeScript.NodeType.None, ">", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanEquals, Reservation.None, OperatorPrecedence.Relational, TypeScript.NodeType.Ge, OperatorPrecedence.None, TypeScript.NodeType.None, ">=", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.LessThanLessThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Lsh, OperatorPrecedence.None, TypeScript.NodeType.None, "<<", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Rsh, OperatorPrecedence.None, TypeScript.NodeType.None, ">>", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.GreaterThanGreaterThanGreaterThan, Reservation.None, OperatorPrecedence.Shift, TypeScript.NodeType.Rs2, OperatorPrecedence.None, TypeScript.NodeType.None, ">>>", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Plus, Reservation.None, OperatorPrecedence.Additive, TypeScript.NodeType.Add, OperatorPrecedence.Unary, TypeScript.NodeType.Pos, "+", TypeScript.ErrorRecoverySet.AddOp);
+ setTokenInfo(TokenID.Minus, Reservation.None, OperatorPrecedence.Additive, TypeScript.NodeType.Sub, OperatorPrecedence.Unary, TypeScript.NodeType.Neg, "-", TypeScript.ErrorRecoverySet.AddOp);
+ setTokenInfo(TokenID.Asterisk, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Mul, OperatorPrecedence.None, TypeScript.NodeType.None, "*", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Slash, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Div, OperatorPrecedence.None, TypeScript.NodeType.None, "/", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Percent, Reservation.None, OperatorPrecedence.Multiplicative, TypeScript.NodeType.Mod, OperatorPrecedence.None, TypeScript.NodeType.None, "%", TypeScript.ErrorRecoverySet.BinOp);
+ setTokenInfo(TokenID.Tilde, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.Not, "~", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.Exclamation, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.LogNot, "!", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.PlusPlus, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.IncPre, "++", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.MinusMinus, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.Unary, TypeScript.NodeType.DecPre, "--", TypeScript.ErrorRecoverySet.PreOp);
+ setTokenInfo(TokenID.OpenParen, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "(", TypeScript.ErrorRecoverySet.LParen);
+ setTokenInfo(TokenID.OpenBracket, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "[", TypeScript.ErrorRecoverySet.LBrack);
+ setTokenInfo(TokenID.Dot, Reservation.None, OperatorPrecedence.Unary, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, ".", TypeScript.ErrorRecoverySet.Dot);
+ setTokenInfo(TokenID.EndOfFile, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "", TypeScript.ErrorRecoverySet.EOF);
+ setTokenInfo(TokenID.EqualsGreaterThan, Reservation.None, OperatorPrecedence.None, TypeScript.NodeType.None, OperatorPrecedence.None, TypeScript.NodeType.None, "=>", TypeScript.ErrorRecoverySet.None);
+ function lookupToken(tokenId) {
+ return TypeScript.tokenTable[tokenId];
+ }
+ TypeScript.lookupToken = lookupToken;
+ (function (TokenClass) {
+ TokenClass._map = [];
+ TokenClass._map[0] = "Punctuation";
+ TokenClass.Punctuation = 0;
+ TokenClass._map[1] = "Keyword";
+ TokenClass.Keyword = 1;
+ TokenClass._map[2] = "Operator";
+ TokenClass.Operator = 2;
+ TokenClass._map[3] = "Comment";
+ TokenClass.Comment = 3;
+ TokenClass._map[4] = "Whitespace";
+ TokenClass.Whitespace = 4;
+ TokenClass._map[5] = "Identifier";
+ TokenClass.Identifier = 5;
+ TokenClass._map[6] = "NumberLiteral";
+ TokenClass.NumberLiteral = 6;
+ TokenClass._map[7] = "StringLiteral";
+ TokenClass.StringLiteral = 7;
+ TokenClass._map[8] = "RegExpLiteral";
+ TokenClass.RegExpLiteral = 8;
+ })(TypeScript.TokenClass || (TypeScript.TokenClass = {}));
+ var TokenClass = TypeScript.TokenClass;
+ var SavedToken = (function () {
+ function SavedToken(tok, minChar, limChar) {
+ this.tok = tok;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ }
+ return SavedToken;
+ })();
+ TypeScript.SavedToken = SavedToken;
+ var Token = (function () {
+ function Token(tokenId) {
+ this.tokenId = tokenId;
+ }
+ Token.prototype.toString = function () {
+ return "token: " + this.tokenId + " " + this.getText() + " (" + (TokenID)._map[this.tokenId] + ")";
+ };
+ Token.prototype.print = function (line, outfile) {
+ outfile.WriteLine(this.toString() + ",on line" + line);
+ };
+ Token.prototype.getText = function () {
+ return TypeScript.tokenTable[this.tokenId].text;
+ };
+ Token.prototype.classification = function () {
+ if(this.tokenId <= TokenID.LimKeyword) {
+ return TokenClass.Keyword;
+ } else {
+ var tokenInfo = lookupToken(this.tokenId);
+ if(tokenInfo != undefined) {
+ if((tokenInfo.unopNodeType != TypeScript.NodeType.None) || (tokenInfo.binopNodeType != TypeScript.NodeType.None)) {
+ return TokenClass.Operator;
+ }
+ }
+ }
+ return TokenClass.Punctuation;
+ };
+ return Token;
+ })();
+ TypeScript.Token = Token;
+ var NumberLiteralToken = (function (_super) {
+ __extends(NumberLiteralToken, _super);
+ function NumberLiteralToken(value, text) {
+ _super.call(this, TokenID.NumberLiteral);
+ this.value = value;
+ this.text = text;
+ }
+ NumberLiteralToken.prototype.getText = function () {
+ return this.text;
+ };
+ 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(text) {
+ _super.call(this, TokenID.RegularExpressionLiteral);
+ this.text = text;
+ }
+ RegularExpressionLiteralToken.prototype.getText = function () {
+ return this.text;
+ };
+ 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.Signature);
+ 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 || !symbol.isType()) {
+ 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 && symbol.declAST && symbol.declAST.nodeType != TypeScript.NodeType.ModuleDeclaration) {
+ context.checker.errorReporter.simpleError(moduleDecl, "Conflicting symbol name for module '" + modName + "'");
+ symbol = null;
+ modName = "";
+ }
+ if(symbol) {
+ var modDeclAST = symbol.declAST;
+ var modDeclASTIsExported = TypeScript.hasFlag(modDeclAST.modFlags, TypeScript.ModuleFlags.Exported);
+ if((modDeclASTIsExported && !isExported) || (!modDeclASTIsExported && isExported)) {
+ context.checker.errorReporter.simpleError(moduleDecl, 'All contributions to a module must be "export" or none');
+ }
+ }
+ 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 {
+ 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;
+ }
+ if(fgSym && !fgSym.isAccessor() && funcDecl.isAccessor()) {
+ fgSym = null;
+ }
+ 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;
+ var svCurrentModDecl = this.checker.currentModDecl;
+ 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;
+ }
+ if(type.isModuleType()) {
+ this.checker.currentModDecl = container.declAST;
+ break;
+ }
+ }
+ container = container.container;
+ }
+ this.typeCheckBoundDecl(varDecl);
+ this.checker.currentModDecl = svCurrentModDecl;
+ 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) {
+ 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)) {
+ if(infSym.typeCheckStatus == TypeScript.TypeCheckStatus.Started) {
+ infSym.declAST.type = this.anyType;
+ infSym.setType(this.anyType);
+ } else {
+ 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]);
+ }
+ 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 (constructorDecl, table, isClass) {
+ var container = constructorDecl.type.symbol;
+ var args = constructorDecl.arguments;
+ 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.funcDecl = constructorDecl;
+ 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;
+ }
+ if(funcDecl.classDecl.type.construct == null) {
+ this.checker.errorReporter.simpleError(funcDecl, "Malformed constructor (is this a class named the same as an existing class?)");
+ 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;
+ 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, 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, 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);
+ }
+ var apparentTarget = target.nodeType == TypeScript.NodeType.Dot ? (target).operand2 : target;
+ 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(apparentTarget, "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(apparentTarget, emsg + ":\n\t" + comparisonInfo.message);
+ } else {
+ this.checker.errorReporter.simpleError(apparentTarget, 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(apparentTarget, "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, getPrettyTypeName) {
+ return this.getMemberTypeName("", true, false, scope, getPrettyTypeName);
+ };
+ Type.prototype.getScopedTypeNameEx = function (scope, getPrettyTypeName) {
+ return this.getMemberTypeNameEx("", true, false, scope, getPrettyTypeName);
+ };
+ 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, getPrettyTypeName) {
+ var memberName = this.getMemberTypeNameEx(prefix, topLevel, isElementType, scope, getPrettyTypeName);
+ return memberName.toString();
+ };
+ Type.prototype.getMemberTypeNameEx = function (prefix, topLevel, isElementType, scope, getPrettyTypeName) {
+ 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 getPrettyFunctionOverload = getPrettyTypeName && !curlies && this.call && this.call.signatures.length > 1 && !this.members && !this.construct;
+ var shortform = !curlies && (signatureCount == 1 || getPrettyFunctionOverload) && topLevel;
+ if(this.call) {
+ allMemberNames.addAll(this.call.toStrings(prefix, shortform, scope, getPrettyFunctionOverload));
+ }
+ if(this.construct) {
+ allMemberNames.addAll(this.construct.toStrings("new", shortform, scope));
+ }
+ if(this.index) {
+ allMemberNames.addAll(this.index.toStrings("", shortform, scope));
+ }
+ if((curlies) || (!getPrettyFunctionOverload && (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 isSingleQuoted(str) {
+ return str.indexOf("'") != -1;
+ }
+ TypeScript.isSingleQuoted = isSingleQuoted;
+ function isQuoted(str) {
+ return str.indexOf("\"") != -1 || isSingleQuoted(str);
+ }
+ 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 changeToSingleQuote(str) {
+ if(str.indexOf("\"") != -1) {
+ str = str.replace("\"", "'");
+ str = str.replace("\"", "'");
+ }
+ return str;
+ }
+ TypeScript.changeToSingleQuote = changeToSingleQuote;
+ 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 = [];
+ this.inputOutputMap = [];
+ }
+ 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: null,
+ 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);
+ return false;
+ }
+ } 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 != null) {
+ var rootDir = ioHost.dirName(resolvedFile.path);
+ var sourceUnit = new SourceUnit(resolvedFile.path, resolvedFile.content);
+ var preProcessedFileInfo = TypeScript.preProcessFile(sourceUnit, this.environment.compilationSettings);
+ var resolvedFilePath = ioHost.resolvePath(resolvedFile.path);
+ sourceUnit.referencedFiles = preProcessedFileInfo.referencedFiles;
+ for(var i = 0; i < preProcessedFileInfo.referencedFiles.length; i++) {
+ var fileReference = preProcessedFileInfo.referencedFiles[i];
+ var normalizedPath = TypeScript.isRooted(fileReference.path) ? fileReference.path : rootDir + "/" + fileReference.path;
+ normalizedPath = ioHost.resolvePath(normalizedPath);
+ if(resolvedFilePath == normalizedPath) {
+ resolutionDispatcher.postResolutionError(normalizedPath, fileReference.startLine, fileReference.startCol, "Incorrect reference: File contains reference to itself.");
+ continue;
+ }
+ var resolutionResult = this.resolveCode(fileReference.path, rootDir, false, resolutionDispatcher);
+ if(!resolutionResult) {
+ resolutionDispatcher.postResolutionError(resolvedFilePath, fileReference.startLine, fileReference.startCol, "Incorrect reference: referenced file: \"" + fileReference.path + "\" cannot be resolved.");
+ }
+ }
+ for(var i = 0; i < preProcessedFileInfo.importedFiles.length; i++) {
+ var fileImport = preProcessedFileInfo.importedFiles[i];
+ var resolutionResult = this.resolveCode(fileImport.path, rootDir, true, resolutionDispatcher);
+ if(!resolutionResult) {
+ resolutionDispatcher.postResolutionError(resolvedFilePath, fileImport.startLine, fileImport.startCol, "Incorrect reference: imported file: \"" + fileImport.path + "\" cannot be resolved.");
+ }
+ }
+ resolutionDispatcher.postResolution(sourceUnit.path, sourceUnit);
+ }
+ }
+ return true;
+ };
+ 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.emitFullSourceMapPath = 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*/gim;
+ 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,
+ startLine: 0,
+ startCol: 0,
+ path: TypeScript.switchToForwardSlashes(adjustedPath),
+ isResident: isResident
+ };
+ } else {
+ return null;
+ }
+ }
+ function getAdditionalDependencyPath(comment) {
+ var amdDependencyRegEx = /^(\/\/\/\s*/gim;
+ 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*/gim;
+ var match = implicitImportRegEx.exec(comment);
+ if(match) {
+ return true;
+ }
+ return false;
+ }
+ TypeScript.getImplicitImport = getImplicitImport;
+ function getStyleSettings(comment, styleSettings) {
+ var styleRegEx = /^(\/\/\/\s*/gim;
+ var settings = styleRegEx.exec(comment);
+ if(settings) {
+ var settingsRegEx = /^([a-zA-Z]+=['"]on['|"])/gim;
+ 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,
+ startLine: scanner.line,
+ startCol: scanner.col,
+ 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;
+ var result = {
+ line: -1,
+ col: -1
+ };
+ TypeScript.getSourceLineColFromMap(result, comment.startPos, scanner.lineMap);
+ if(result.col >= 0) {
+ result.col++;
+ }
+ referencedCode.startLine = result.line;
+ referencedCode.startCol = result.col;
+ referencedFiles.push(referencedCode);
+ }
+ if(settings) {
+ getStyleSettings(comment.getText(), settings.styleSettings);
+ var isNoLibRegex = /^(\/\/\/\s*/gim;
+ 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)) {
+ if(TypeScript.hasFlag(declFlags, TypeScript.DeclFlags.Private)) {
+ result += "private ";
+ }
+ 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");
+ if(id != "__missing" || !funcDecl.name || !funcDecl.name.isMissing()) {
+ this.declFile.Write(id);
+ } else if(funcDecl.isConstructMember()) {
+ this.declFile.Write("new");
+ }
+ } else {
+ this.emitIndent();
+ if(funcDecl.isConstructMember()) {
+ this.declFile.Write("new");
+ } else if(!funcDecl.isCallMember() && !funcDecl.isIndexerMember()) {
+ this.declFile.Write(id);
+ if(TypeScript.hasFlag(funcDecl.name.flags, TypeScript.ASTFlags.OptionalName)) {
+ this.declFile.Write("? ");
+ }
+ }
+ }
+ }
+ if(!funcDecl.isIndexerMember()) {
+ this.declFile.Write("(");
+ } else {
+ this.declFile.Write("[");
+ }
+ this.indenter.increaseIndent();
+ if(funcDecl.arguments) {
+ var argsLen = funcDecl.arguments.members.length;
+ if(funcDecl.variableArgList) {
+ argsLen--;
+ }
+ for(var i = 0; i < argsLen; i++) {
+ var argDecl = funcDecl.arguments.members[i];
+ this.emitArgDecl(argDecl, funcDecl);
+ if(i < (argsLen - 1)) {
+ this.declFile.Write(", ");
+ }
+ }
+ }
+ if(funcDecl.variableArgList) {
+ var lastArg = funcDecl.arguments.members[funcDecl.arguments.members.length - 1];
+ if(funcDecl.arguments.members.length > 1) {
+ this.declFile.Write(", ...");
+ } else {
+ this.declFile.Write("...");
+ }
+ this.emitArgDecl(lastArg, funcDecl);
+ }
+ this.indenter.decreaseIndent();
+ if(!funcDecl.isIndexerMember()) {
+ this.declFile.Write(")");
+ } else {
+ this.declFile.Write("]");
+ }
+ if(!funcDecl.isConstructor && (funcDecl.returnTypeAnnotation || funcDecl.signature.returnType.type != this.checker.anyType) && this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(funcDecl.fncFlags))) {
+ this.declFile.Write(": ");
+ this.emitTypeSignature(funcDecl.signature.returnType.type);
+ }
+ this.declFile.WriteLine(";");
+ return false;
+ };
+ DeclarationEmitter.prototype.emitBaseList = function (bases, qual) {
+ if(bases && (bases.members.length > 0)) {
+ this.declFile.Write(" " + qual + " ");
+ var basesLen = bases.members.length;
+ for(var i = 0; i < basesLen; i++) {
+ var baseExpr = bases.members[i];
+ var baseSymbol = baseExpr.type.symbol;
+ var baseType = baseExpr.type;
+ if(i > 0) {
+ this.declFile.Write(", ");
+ }
+ this.emitTypeSignature(baseType);
+ }
+ }
+ };
+ DeclarationEmitter.prototype.emitPropertyAccessorSignature = function (funcDecl) {
+ var accessorSymbol = funcDecl.accessorSymbol;
+ if(accessorSymbol.getter && accessorSymbol.getter.declAST != funcDecl) {
+ return false;
+ }
+ this.emitDeclarationComments(accessorSymbol);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(accessorSymbol.flags), "var");
+ this.declFile.Write(funcDecl.name.text);
+ var propertyType = accessorSymbol.getType();
+ if(this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(accessorSymbol.flags))) {
+ this.declFile.Write(" : ");
+ this.emitTypeSignature(propertyType);
+ }
+ this.declFile.WriteLine(";");
+ return false;
+ };
+ DeclarationEmitter.prototype.emitClassMembersFromConstructorDefinition = function (funcDecl) {
+ if(funcDecl.arguments) {
+ var argsLen = funcDecl.arguments.members.length;
+ if(funcDecl.variableArgList) {
+ argsLen--;
+ }
+ for(var i = 0; i < argsLen; i++) {
+ var argDecl = funcDecl.arguments.members[i];
+ if(TypeScript.hasFlag(argDecl.varFlags, TypeScript.VarFlags.Property)) {
+ this.emitDeclarationComments(argDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(argDecl.varFlags), "var");
+ this.declFile.Write(argDecl.id.text);
+ if(argDecl.typeExpr && this.canEmitTypeAnnotationSignature(TypeScript.ToDeclFlags(argDecl.varFlags))) {
+ this.declFile.Write(": ");
+ this.emitTypeSignature(argDecl.type);
+ }
+ this.declFile.WriteLine(";");
+ }
+ }
+ }
+ };
+ DeclarationEmitter.prototype.ClassDeclarationCallback = function (pre, classDecl) {
+ if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(classDecl.varFlags), classDecl, pre)) {
+ return false;
+ }
+ if(pre) {
+ var className = classDecl.name.text;
+ this.emitDeclarationComments(classDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(classDecl.varFlags), "class");
+ this.declFile.Write(className);
+ this.emitBaseList(classDecl.extendsList, "extends");
+ this.emitBaseList(classDecl.implementsList, "implements");
+ this.declFile.WriteLine(" {");
+ this.pushDeclarationContainer(classDecl);
+ this.indenter.increaseIndent();
+ if(classDecl.constructorDecl) {
+ this.emitClassMembersFromConstructorDefinition(classDecl.constructorDecl);
+ }
+ } else {
+ this.indenter.decreaseIndent();
+ this.popDeclarationContainer(classDecl);
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.InterfaceDeclarationCallback = function (pre, interfaceDecl) {
+ if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(interfaceDecl.varFlags), interfaceDecl, pre)) {
+ return false;
+ }
+ if(pre) {
+ var interfaceName = interfaceDecl.name.text;
+ this.emitDeclarationComments(interfaceDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(interfaceDecl.varFlags), "interface");
+ this.declFile.Write(interfaceName);
+ this.emitBaseList(interfaceDecl.extendsList, "extends");
+ this.declFile.WriteLine(" {");
+ this.indenter.increaseIndent();
+ this.pushDeclarationContainer(interfaceDecl);
+ } else {
+ this.indenter.decreaseIndent();
+ this.popDeclarationContainer(interfaceDecl);
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.ImportDeclarationCallback = function (pre, importDecl) {
+ if(pre) {
+ if((this.declarationContainerStack[0]).isExternallyVisibleSymbol(importDecl.id.sym)) {
+ this.emitDeclarationComments(importDecl);
+ this.emitIndent();
+ this.declFile.Write("import ");
+ this.declFile.Write(importDecl.id.text + " = ");
+ if(importDecl.isDynamicImport) {
+ this.declFile.WriteLine("module (" + importDecl.getAliasName() + ");");
+ } else {
+ this.declFile.WriteLine(importDecl.getAliasName() + ";");
+ }
+ }
+ }
+ return false;
+ };
+ DeclarationEmitter.prototype.emitEnumSignature = function (moduleDecl) {
+ if(!this.canEmitSignature(TypeScript.ToDeclFlags(moduleDecl.modFlags))) {
+ return false;
+ }
+ this.emitDeclarationComments(moduleDecl);
+ this.emitDeclFlags(TypeScript.ToDeclFlags(moduleDecl.modFlags), "enum");
+ this.declFile.WriteLine(moduleDecl.name.text + " {");
+ this.indenter.increaseIndent();
+ var membersLen = moduleDecl.members.members.length;
+ for(var j = 1; j < membersLen; j++) {
+ var memberDecl = moduleDecl.members.members[j];
+ if(memberDecl.nodeType == TypeScript.NodeType.VarDecl) {
+ this.emitDeclarationComments(memberDecl);
+ this.emitIndent();
+ this.declFile.WriteLine((memberDecl).id.text + ",");
+ } else {
+ TypeScript.CompilerDiagnostics.assert(memberDecl.nodeType != TypeScript.NodeType.Asg, "We want to catch this");
+ }
+ }
+ this.indenter.decreaseIndent();
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ return false;
+ };
+ DeclarationEmitter.prototype.ModuleDeclarationCallback = function (pre, moduleDecl) {
+ if(TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsWholeFile)) {
+ if(TypeScript.hasFlag(moduleDecl.modFlags, TypeScript.ModuleFlags.IsDynamic)) {
+ if(pre) {
+ if(!this.emitOptions.outputMany) {
+ this.singleDeclFile = this.declFile;
+ TypeScript.CompilerDiagnostics.assert(this.indenter.indentAmt == 0, "Indent has to be 0 when outputing new file");
+ var declareFileName = this.emitOptions.mapOutputFileName(TypeScript.stripQuotes(moduleDecl.name.sym.name), TypeScript.TypeScriptCompiler.mapToDTSFileName);
+ var useUTF8InOutputfile = moduleDecl.containsUnicodeChar || (this.emitOptions.emitComments && moduleDecl.containsUnicodeCharInComment);
+ try {
+ this.declFile = new DeclFileWriter(this.emitOptions.ioHost.createFile(declareFileName, useUTF8InOutputfile));
+ } catch (ex) {
+ this.errorReporter.emitterError(null, ex.message);
+ }
+ }
+ this.pushDeclarationContainer(moduleDecl);
+ } else {
+ if(!this.emitOptions.outputMany) {
+ TypeScript.CompilerDiagnostics.assert(this.singleDeclFile != this.declFile, "singleDeclFile cannot be null as we are going to revert back to it");
+ TypeScript.CompilerDiagnostics.assert(this.indenter.indentAmt == 0, "Indent has to be 0 when outputing new file");
+ try {
+ this.declFile.Close();
+ } catch (ex) {
+ this.errorReporter.emitterError(null, ex.message);
+ }
+ this.declFile = this.singleDeclFile;
+ }
+ this.popDeclarationContainer(moduleDecl);
+ }
+ }
+ return true;
+ }
+ if(moduleDecl.isEnum()) {
+ if(pre) {
+ this.emitEnumSignature(moduleDecl);
+ }
+ return false;
+ }
+ if(!this.canEmitPrePostAstSignature(TypeScript.ToDeclFlags(moduleDecl.modFlags), moduleDecl, pre)) {
+ return false;
+ }
+ if(pre) {
+ if(this.emitDottedModuleName()) {
+ this.dottedModuleEmit += ".";
+ } else {
+ this.dottedModuleEmit = this.getDeclFlagsString(TypeScript.ToDeclFlags(moduleDecl.modFlags), "module");
+ }
+ this.dottedModuleEmit += moduleDecl.name.text;
+ var isCurrentModuleDotted = (moduleDecl.members.members.length == 1 && moduleDecl.members.members[0].nodeType == TypeScript.NodeType.ModuleDeclaration && !(moduleDecl.members.members[0]).isEnum() && TypeScript.hasFlag((moduleDecl.members.members[0]).modFlags, TypeScript.ModuleFlags.Exported));
+ var moduleDeclComments = moduleDecl.getDocComments();
+ isCurrentModuleDotted = isCurrentModuleDotted && (moduleDeclComments == null || moduleDeclComments.length == 0);
+ this.isDottedModuleName.push(isCurrentModuleDotted);
+ this.pushDeclarationContainer(moduleDecl);
+ if(!isCurrentModuleDotted) {
+ this.emitDeclarationComments(moduleDecl);
+ this.declFile.Write(this.dottedModuleEmit);
+ this.declFile.WriteLine(" {");
+ this.indenter.increaseIndent();
+ }
+ } else {
+ if(!this.emitDottedModuleName()) {
+ this.indenter.decreaseIndent();
+ this.emitIndent();
+ this.declFile.WriteLine("}");
+ }
+ this.popDeclarationContainer(moduleDecl);
+ this.isDottedModuleName.pop();
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.ScriptCallback = function (pre, script) {
+ if(pre) {
+ if(this.emitOptions.outputMany) {
+ for(var i = 0; i < script.referencedFiles.length; i++) {
+ var referencePath = script.referencedFiles[i].path;
+ var declareFileName;
+ if(TypeScript.isRooted(referencePath)) {
+ declareFileName = this.emitOptions.mapOutputFileName(referencePath, TypeScript.TypeScriptCompiler.mapToDTSFileName);
+ } else {
+ declareFileName = TypeScript.getDeclareFilePath(script.referencedFiles[i].path);
+ }
+ this.declFile.WriteLine('/// ');
+ }
+ }
+ this.pushDeclarationContainer(script);
+ } else {
+ this.popDeclarationContainer(script);
+ }
+ return true;
+ };
+ DeclarationEmitter.prototype.DefaultCallback = function (pre, ast) {
+ return !TypeScript.hasFlag(ast.flags, TypeScript.ASTFlags.IsStatement);
+ };
+ return DeclarationEmitter;
+ })();
+ TypeScript.DeclarationEmitter = DeclarationEmitter;
+})(TypeScript || (TypeScript = {}));
+var TypeScript;
+(function (TypeScript) {
+ (function (UpdateUnitKind) {
+ UpdateUnitKind._map = [];
+ UpdateUnitKind._map[0] = "Unknown";
+ UpdateUnitKind.Unknown = 0;
+ UpdateUnitKind._map[1] = "NoEdits";
+ UpdateUnitKind.NoEdits = 1;
+ UpdateUnitKind._map[2] = "EditsInsideSingleScope";
+ UpdateUnitKind.EditsInsideSingleScope = 2;
+ })(TypeScript.UpdateUnitKind || (TypeScript.UpdateUnitKind = {}));
+ var UpdateUnitKind = TypeScript.UpdateUnitKind;
+ var ScriptEditRange = (function () {
+ function ScriptEditRange(minChar, limChar, delta) {
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.delta = delta;
+ }
+ ScriptEditRange.unknown = function unknown() {
+ return new ScriptEditRange(-1, -1, -1);
+ };
+ ScriptEditRange.prototype.isUnknown = function () {
+ return this.minChar === -1 && this.limChar === -1 && this.delta === -1;
+ };
+ ScriptEditRange.prototype.containsPosition = function (pos) {
+ return (this.minChar <= pos && pos < this.limChar) || (this.minChar <= pos && pos < this.limChar + this.delta);
+ };
+ ScriptEditRange.prototype.toString = function () {
+ return "editRange(minChar=" + this.minChar + ", limChar=" + this.limChar + ", delta=" + this.delta + ")";
+ };
+ return ScriptEditRange;
+ })();
+ TypeScript.ScriptEditRange = ScriptEditRange;
+ var UpdateUnitResult = (function () {
+ function UpdateUnitResult(kind, unitIndex, script1, script2) {
+ this.kind = kind;
+ this.unitIndex = unitIndex;
+ this.script1 = script1;
+ this.script2 = script2;
+ this.scope1 = null;
+ this.scope2 = null;
+ this.editRange = null;
+ this.parseErrors = [];
+ }
+ UpdateUnitResult.noEdits = function noEdits(unitIndex) {
+ return new UpdateUnitResult(UpdateUnitKind.NoEdits, unitIndex, null, null);
+ };
+ UpdateUnitResult.unknownEdits = function unknownEdits(script1, script2, parseErrors) {
+ var result = new UpdateUnitResult(UpdateUnitKind.Unknown, script1.locationInfo.unitIndex, script1, script2);
+ result.parseErrors = parseErrors;
+ return result;
+ };
+ UpdateUnitResult.singleScopeEdits = function singleScopeEdits(script1, script2, scope1, scope2, editRange, parseErrors) {
+ var result = new UpdateUnitResult(UpdateUnitKind.EditsInsideSingleScope, script1.locationInfo.unitIndex, script1, script2);
+ result.scope1 = scope1;
+ result.scope2 = scope2;
+ result.editRange = editRange;
+ result.parseErrors = parseErrors;
+ return result;
+ };
+ return UpdateUnitResult;
+ })();
+ TypeScript.UpdateUnitResult = UpdateUnitResult;
+ var ErrorEntry = (function () {
+ function ErrorEntry(unitIndex, minChar, limChar, message) {
+ this.unitIndex = unitIndex;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.message = message;
+ }
+ return ErrorEntry;
+ })();
+ TypeScript.ErrorEntry = ErrorEntry;
+ TypeScript.defaultSettings = new TypeScript.CompilationSettings();
+ var TypeScriptCompiler = (function () {
+ function TypeScriptCompiler(errorOutput, logger, settings) {
+ if (typeof logger === "undefined") { logger = new TypeScript.NullLogger(); }
+ if (typeof settings === "undefined") { settings = TypeScript.defaultSettings; }
+ this.errorOutput = errorOutput;
+ this.logger = logger;
+ this.settings = settings;
+ this.parser = new TypeScript.Parser();
+ this.typeFlow = null;
+ this.scripts = new TypeScript.ASTList();
+ this.units = new Array();
+ this.errorReporter = new TypeScript.ErrorReporter(this.errorOutput);
+ this.persistentTypeState = new TypeScript.PersistentGlobalTypeState(this.errorReporter);
+ this.errorReporter.parser = this.parser;
+ this.initTypeChecker(this.errorOutput);
+ this.parser.style_requireSemi = this.settings.styleSettings.requireSemi;
+ this.parser.style_funcInLoop = this.settings.styleSettings.funcInLoop;
+ this.parser.inferPropertiesFromThisAssignment = this.settings.inferPropertiesFromThisAssignment;
+ this.emitSettings = new TypeScript.EmitOptions(this.settings);
+ TypeScript.codeGenTarget = settings.codeGenTarget;
+ }
+ TypeScriptCompiler.prototype.timeFunction = function (funcDescription, func) {
+ return TypeScript.timeFunction(this.logger, funcDescription, func);
+ };
+ TypeScriptCompiler.prototype.initTypeChecker = function (errorOutput) {
+ this.persistentTypeState.refreshPersistentState();
+ this.typeChecker = new TypeScript.TypeChecker(this.persistentTypeState);
+ this.typeChecker.errorReporter = this.errorReporter;
+ this.typeChecker.checkControlFlow = this.settings.controlFlow;
+ this.typeChecker.checkControlFlowUseDef = this.settings.controlFlowUseDef;
+ this.typeChecker.printControlFlowGraph = this.settings.printControlFlow;
+ this.typeChecker.errorsOnWith = this.settings.errorOnWith;
+ this.typeChecker.styleSettings = this.settings.styleSettings;
+ this.typeChecker.canCallDefinitionSignature = this.settings.canCallDefinitionSignature;
+ this.errorReporter.checker = this.typeChecker;
+ this.setErrorOutput(this.errorOutput);
+ };
+ TypeScriptCompiler.prototype.setErrorOutput = function (outerr) {
+ this.errorOutput = outerr;
+ this.errorReporter.setErrOut(outerr);
+ this.parser.outfile = outerr;
+ };
+ TypeScriptCompiler.prototype.emitCommentsToOutput = function () {
+ this.emitSettings = new TypeScript.EmitOptions(this.settings);
+ };
+ TypeScriptCompiler.prototype.setErrorCallback = function (fn) {
+ this.parser.errorCallback = fn;
+ };
+ TypeScriptCompiler.prototype.updateUnit = function (prog, filename, setRecovery) {
+ return this.updateSourceUnit(new TypeScript.StringSourceText(prog), filename, setRecovery);
+ };
+ TypeScriptCompiler.prototype.updateSourceUnit = function (sourceText, filename, setRecovery) {
+ var _this = this;
+ return this.timeFunction("updateSourceUnit(" + filename + ")", function () {
+ var updateResult = _this.partialUpdateUnit(sourceText, filename, setRecovery);
+ return _this.applyUpdateResult(updateResult);
+ });
+ };
+ TypeScriptCompiler.prototype.applyUpdateResult = function (updateResult) {
+ switch(updateResult.kind) {
+ case UpdateUnitKind.NoEdits:
+ return false;
+ case UpdateUnitKind.Unknown:
+ this.scripts.members[updateResult.unitIndex] = updateResult.script2;
+ this.units[updateResult.unitIndex] = updateResult.script2.locationInfo;
+ for(var i = 0, len = updateResult.parseErrors.length; i < len; i++) {
+ var e = updateResult.parseErrors[i];
+ if(this.parser.errorCallback) {
+ this.parser.errorCallback(e.minChar, e.limChar - e.minChar, e.message, e.unitIndex);
+ }
+ }
+ return true;
+ case UpdateUnitKind.EditsInsideSingleScope:
+ new TypeScript.IncrementalParser(this.logger).mergeTrees(updateResult);
+ return true;
+ }
+ };
+ TypeScriptCompiler.prototype.partialUpdateUnit = function (sourceText, filename, setRecovery) {
+ var _this = this;
+ return this.timeFunction("partialUpdateUnit(" + filename + ")", function () {
+ for(var i = 0, len = _this.units.length; i < len; i++) {
+ if(_this.units[i].filename == filename) {
+ if((_this.scripts.members[i]).isResident) {
+ return UpdateUnitResult.noEdits(i);
+ }
+ if(setRecovery) {
+ _this.parser.setErrorRecovery(null);
+ }
+ var updateResult;
+ var parseErrors = [];
+ var errorCapture = function (minChar, charLen, message, unitIndex) {
+ parseErrors.push(new ErrorEntry(unitIndex, minChar, minChar + charLen, message));
+ };
+ var svErrorCallback = _this.parser.errorCallback;
+ if(svErrorCallback) {
+ _this.parser.errorCallback = errorCapture;
+ }
+ var oldScript = _this.scripts.members[i];
+ var newScript = _this.parser.parse(sourceText, filename, i);
+ if(svErrorCallback) {
+ _this.parser.errorCallback = svErrorCallback;
+ }
+ updateResult = UpdateUnitResult.unknownEdits(oldScript, newScript, parseErrors);
+ return updateResult;
+ }
+ }
+ throw new Error("Unknown file \"" + filename + "\"");
+ });
+ };
+ TypeScriptCompiler.prototype.addUnit = function (prog, filename, keepResident, referencedFiles) {
+ if (typeof keepResident === "undefined") { keepResident = false; }
+ if (typeof referencedFiles === "undefined") { referencedFiles = []; }
+ return this.addSourceUnit(new TypeScript.StringSourceText(prog), filename, keepResident, referencedFiles);
+ };
+ TypeScriptCompiler.prototype.addSourceUnit = function (sourceText, filename, keepResident, referencedFiles) {
+ if (typeof referencedFiles === "undefined") { referencedFiles = []; }
+ var _this = this;
+ return this.timeFunction("addSourceUnit(" + filename + ", " + keepResident + ")", function () {
+ var script = _this.parser.parse(sourceText, filename, _this.units.length, TypeScript.AllowedElements.Global);
+ script.referencedFiles = referencedFiles;
+ script.isResident = keepResident;
+ _this.persistentTypeState.setCollectionMode(keepResident ? TypeScript.TypeCheckCollectionMode.Resident : TypeScript.TypeCheckCollectionMode.Transient);
+ var index = _this.units.length;
+ _this.units[index] = script.locationInfo;
+ _this.typeChecker.collectTypes(script);
+ _this.scripts.append(script);
+ return script;
+ });
+ };
+ TypeScriptCompiler.prototype.parseUnit = function (prog, filename) {
+ return this.parseSourceUnit(new TypeScript.StringSourceText(prog), filename);
+ };
+ TypeScriptCompiler.prototype.parseSourceUnit = function (sourceText, filename) {
+ this.parser.setErrorRecovery(this.errorOutput);
+ var script = this.parser.parse(sourceText, filename, 0);
+ var index = this.units.length;
+ this.units[index] = script.locationInfo;
+ this.typeChecker.collectTypes(script);
+ this.scripts.append(script);
+ };
+ TypeScriptCompiler.prototype.typeCheck = function () {
+ var _this = this;
+ return this.timeFunction("typeCheck()", function () {
+ var binder = new TypeScript.Binder(_this.typeChecker);
+ _this.typeChecker.units = _this.units;
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.globals);
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.ambientGlobals);
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.globalTypes);
+ binder.bind(_this.typeChecker.globalScope, _this.typeChecker.ambientGlobalTypes);
+ _this.typeFlow = new TypeScript.TypeFlow(_this.logger, _this.typeChecker.globalScope, _this.parser, _this.typeChecker);
+ var i = 0;
+ var script = null;
+ var len = _this.scripts.members.length;
+ _this.persistentTypeState.setCollectionMode(TypeScript.TypeCheckCollectionMode.Resident);
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(!script.isResident || script.hasBeenTypeChecked) {
+ continue;
+ }
+ _this.typeFlow.assignScopes(script);
+ _this.typeFlow.initLibs();
+ }
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(!script.isResident || script.hasBeenTypeChecked) {
+ continue;
+ }
+ _this.typeFlow.typeCheck(script);
+ script.hasBeenTypeChecked = true;
+ }
+ _this.persistentTypeState.setCollectionMode(TypeScript.TypeCheckCollectionMode.Transient);
+ len = _this.scripts.members.length;
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(script.isResident) {
+ continue;
+ }
+ _this.typeFlow.assignScopes(script);
+ _this.typeFlow.initLibs();
+ }
+ for(i = 0; i < len; i++) {
+ script = _this.scripts.members[i];
+ if(script.isResident) {
+ continue;
+ }
+ _this.typeFlow.typeCheck(script);
+ }
+ return null;
+ });
+ };
+ TypeScriptCompiler.prototype.cleanASTTypesForReTypeCheck = function (ast) {
+ function cleanASTType(ast, parent) {
+ ast.type = null;
+ if(ast.nodeType == TypeScript.NodeType.VarDecl) {
+ var vardecl = ast;
+ vardecl.sym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.ArgDecl) {
+ var argdecl = ast;
+ argdecl.sym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.Name) {
+ var name = ast;
+ name.sym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.FuncDecl) {
+ var funcdecl = ast;
+ funcdecl.signature = null;
+ funcdecl.freeVariables = new Array();
+ funcdecl.symbols = null;
+ funcdecl.accessorSymbol = null;
+ funcdecl.scopeType = null;
+ } else if(ast.nodeType == TypeScript.NodeType.ModuleDeclaration) {
+ var modDecl = ast;
+ modDecl.mod = null;
+ } else if(ast.nodeType == TypeScript.NodeType.With) {
+ (ast).withSym = null;
+ } else if(ast.nodeType == TypeScript.NodeType.Catch) {
+ (ast).containedScope = null;
+ } else if(ast.nodeType === TypeScript.NodeType.Script) {
+ (ast).externallyVisibleImportedSymbols = [];
+ }
+ 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, inputOutputMapper) {
+ 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, this.settings.emitFullSourceMapPath));
+ }
+ if(inputOutputMapper) {
+ inputOutputMapper(script.locationInfo.unitIndex, outFname);
+ }
+ } else if(this.settings.mapSourceFiles) {
+ emitter.setSourceMappings(new TypeScript.SourceMapper(fname, emitter.emittingFileName, emitter.outfile, emitter.sourceMapper.sourceMapOut, this.errorReporter, this.settings.emitFullSourceMapPath));
+ }
+ 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, inputOutputMapper) {
+ 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, null, inputOutputMapper);
+ } 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, getPrettyTypeName) {
+ 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, getPrettyTypeName);
+ this.compiler.typeChecker.currentModDecl = svModuleDecl;
+ return result;
+ };
+ ScopeTraversal.prototype.getTypeNamesForNames = function (enclosingScopeContext, allNames, scope, getPrettyTypeName) {
+ 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 getPrettyOverload = getPrettyTypeName && symbol.declAST && symbol.declAST.nodeType == TypeScript.NodeType.FuncDecl;
+ var type = symbol.getType();
+ var typeName = type ? type.getScopedTypeName(enclosingScope, getPrettyOverload) : "";
+ 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 0x09:
+ result += "\\t";
+ break;
+ case 0x0a:
+ result += "\\n";
+ break;
+ case 0x0b:
+ result += "\\v";
+ break;
+ case 0x0c:
+ result += "\\f";
+ break;
+ case 0x0d:
+ result += "\\r";
+ break;
+ case 0x22:
+ result += "\\\"";
+ break;
+ case 0x27:
+ result += "\\\'";
+ break;
+ case 0x5c:
+ 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 = {}));
+if(!String.prototype.trim) {
+ String.prototype.trim = function () {
+ return this.replace(/^\s+|\s+$/g, '');
+ };
+}
+if(!Array.prototype.indexOf) {
+ Array.prototype.indexOf = function (searchElement, fromIndex) {
+ "use strict";
+ if(this == null) {
+ throw new TypeError();
+ }
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if(len === 0) {
+ return -1;
+ }
+ var n = 0;
+ if(arguments.length > 0) {
+ n = Number(arguments[1]);
+ if(n != n) {
+ n = 0;
+ } else if(n != 0 && n != Infinity && n != -Infinity) {
+ n = (n > 0 || -1) * Math.floor(Math.abs(n));
+ }
+ }
+ if(n >= len) {
+ return -1;
+ }
+ var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
+ for(; k < len; k++) {
+ if(k in t && t[k] === searchElement) {
+ return k;
+ }
+ }
+ return -1;
+ };
+}
+if(!Array.prototype.filter) {
+ Array.prototype.filter = function (fun, thisp) {
+ "use strict";
+ if(this == null) {
+ throw new TypeError();
+ }
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if(typeof fun != "function") {
+ throw new TypeError();
+ }
+ var res = [];
+ var thisp = arguments[1];
+ for(var i = 0; i < len; i++) {
+ if(i in t) {
+ var val = t[i];
+ if(fun.call(thisp, val, i, t)) {
+ res.push(val);
+ }
+ }
+ }
+ return res;
+ };
+}
+if(!Array.prototype.map) {
+ Array.prototype.map = function (callback, thisArg) {
+ var T = undefined, A, k;
+ if(this == null) {
+ throw new TypeError(" this is null or not defined");
+ }
+ var O = Object(this);
+ var len = O.length >>> 0;
+ if({
+ }.toString.call(callback) != "[object Function]") {
+ throw new TypeError(callback + " is not a function");
+ }
+ if(thisArg) {
+ T = thisArg;
+ }
+ A = new Array(len);
+ k = 0;
+ while(k < len) {
+ var kValue, mappedValue;
+ if(k in O) {
+ kValue = O[k];
+ mappedValue = callback.call(T, kValue, k, O);
+ A[k] = mappedValue;
+ }
+ k++;
+ }
+ return A;
+ };
+}
+if(!Array.prototype.reduce) {
+ Array.prototype.reduce = function reduce(accumulator) {
+ if(this === null || this === undefined) {
+ throw new TypeError("Object is null or undefined");
+ }
+ var i = 0, l = this.length >> 0, curr;
+ if(typeof accumulator !== "function") {
+ throw new TypeError("First argument is not callable");
+ }
+ if(arguments.length < 2) {
+ if(l === 0) {
+ throw new TypeError("Array length is 0 and no second argument");
+ }
+ curr = this[0];
+ i = 1;
+ } else {
+ curr = arguments[1];
+ }
+ while(i < l) {
+ if(i in this) {
+ curr = accumulator.call(undefined, curr, this[i], i, this);
+ }
+ ++i;
+ }
+ return curr;
+ };
+}
+if(!Array.prototype.forEach) {
+ Array.prototype.forEach = function (callback, thisArg) {
+ var T, k;
+ if(this == null) {
+ throw new TypeError(" this is null or not defined");
+ }
+ var O = Object(this);
+ var len = O.length >>> 0;
+ if({
+ }.toString.call(callback) != "[object Function]") {
+ throw new TypeError(callback + " is not a function");
+ }
+ if(thisArg) {
+ T = thisArg;
+ } else {
+ T = undefined;
+ }
+ k = 0;
+ while(k < len) {
+ var kValue;
+ if(k in O) {
+ kValue = O[k];
+ callback.call(T, kValue, k, O);
+ }
+ k++;
+ }
+ };
+}
+if(!Date.now) {
+ (Date).now = function () {
+ return +(new Date());
+ };
+}
+if(!Array.prototype.some) {
+ Array.prototype.some = function (fun) {
+ "use strict";
+ if(this == null) {
+ throw new TypeError();
+ }
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if(typeof fun != "function") {
+ throw new TypeError();
+ }
+ var thisp = arguments[1];
+ for(var i = 0; i < len; i++) {
+ var idx = i.toString();
+ if(idx in t && fun.call(thisp, t[i], i, t)) {
+ return true;
+ }
+ }
+ return false;
+ };
+}
+var Services;
+(function (Services) {
+ var Classifier = (function () {
+ function Classifier(host) {
+ this.host = host;
+ this.scanner = new TypeScript.Scanner();
+ }
+ Classifier.prototype.getClassificationsForLine = function (text, lexState) {
+ var result = new ClassificationResult();
+ result.initialState = lexState;
+ this.scanner.lexState = lexState;
+ this.scanner.setText(text, TypeScript.LexMode.Line);
+ var t = this.scanner.scanInLine();
+ while(t.tokenId != TypeScript.TokenID.EndOfFile) {
+ result.entries.push(new ClassificationInfo(this.scanner.pos, t.classification()));
+ t = this.scanner.scanInLine();
+ }
+ result.finalLexState = this.scanner.lexState;
+ return result;
+ };
+ return Classifier;
+ })();
+ Services.Classifier = Classifier;
+ var ClassificationResult = (function () {
+ function ClassificationResult() {
+ this.initialState = TypeScript.LexState.Start;
+ this.finalLexState = TypeScript.LexState.Start;
+ this.entries = [];
+ }
+ return ClassificationResult;
+ })();
+ Services.ClassificationResult = ClassificationResult;
+ var ClassificationInfo = (function () {
+ function ClassificationInfo(length, classification) {
+ this.length = length;
+ this.classification = classification;
+ }
+ return ClassificationInfo;
+ })();
+ Services.ClassificationInfo = ClassificationInfo;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ function logInternalError(logger, err) {
+ logger.log("*INTERNAL ERROR* - Exception in typescript services: " + err.message);
+ }
+ Services.logInternalError = logInternalError;
+ var SourceTextAdapter = (function () {
+ function SourceTextAdapter(host, scriptIndex) {
+ this.host = host;
+ this.scriptIndex = scriptIndex;
+ }
+ SourceTextAdapter.prototype.getText = function (start, end) {
+ return this.host.getScriptSourceText(this.scriptIndex, start, end);
+ };
+ SourceTextAdapter.prototype.getLength = function () {
+ return this.host.getScriptSourceLength(this.scriptIndex);
+ };
+ return SourceTextAdapter;
+ })();
+ Services.SourceTextAdapter = SourceTextAdapter;
+ var CachedSourceTextAdapter = (function () {
+ function CachedSourceTextAdapter(host, scriptIndex) {
+ this.length = host.getScriptSourceLength(scriptIndex);
+ this.text = host.getScriptSourceText(scriptIndex, 0, this.length);
+ }
+ CachedSourceTextAdapter.prototype.getText = function (start, end) {
+ return this.text.substring(start, end);
+ };
+ CachedSourceTextAdapter.prototype.getLength = function () {
+ return this.length;
+ };
+ return CachedSourceTextAdapter;
+ })();
+ Services.CachedSourceTextAdapter = CachedSourceTextAdapter;
+ var SourceTextRange = (function () {
+ function SourceTextRange(sourceText, minChar, limChar) {
+ this.sourceText = sourceText;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ }
+ SourceTextRange.prototype.getText = function (start, end) {
+ var actualStart = this.minChar + start;
+ var actualEnd = this.minChar + end;
+ if(actualEnd > this.limChar) {
+ actualEnd = this.limChar;
+ }
+ return this.sourceText.getText(actualStart, actualEnd);
+ };
+ SourceTextRange.prototype.getLength = function () {
+ return this.limChar - this.minChar;
+ };
+ return SourceTextRange;
+ })();
+ Services.SourceTextRange = SourceTextRange;
+ var ReferenceEntry = (function () {
+ function ReferenceEntry(unitIndex, ast, isWriteAccess) {
+ this.unitIndex = unitIndex;
+ this.ast = ast;
+ this.isWriteAccess = isWriteAccess;
+ }
+ ReferenceEntry.prototype.getHashCode = function () {
+ return TypeScript.combineHashes(TypeScript.numberHashFn(this.unitIndex), TypeScript.combineHashes(TypeScript.numberHashFn(this.ast.minChar), TypeScript.numberHashFn(this.ast.limChar)));
+ };
+ ReferenceEntry.prototype.equals = function (other) {
+ if(other === null || other === undefined) {
+ return false;
+ }
+ return (this.unitIndex === other.unitIndex) && (this.ast.minChar === other.ast.minChar) && (this.ast.limChar === other.ast.limChar);
+ };
+ return ReferenceEntry;
+ })();
+ Services.ReferenceEntry = ReferenceEntry;
+ var ReferenceEntrySet = (function () {
+ function ReferenceEntrySet() {
+ this.entries = [];
+ this.hashTable = new TypeScript.HashTable(101, function (r) {
+ return r.getHashCode();
+ }, function (r1, r2) {
+ return r1.equals(r2);
+ });
+ }
+ ReferenceEntrySet.prototype.getEntries = function () {
+ return this.entries;
+ };
+ ReferenceEntrySet.prototype.addAst = function (unitIndex, ast, isWriteAccess) {
+ var reference = new ReferenceEntry(unitIndex, ast, isWriteAccess);
+ if(this.hashTable.lookup(reference) !== null) {
+ return;
+ }
+ this.hashTable.add(reference, reference);
+ this.entries.push(reference);
+ };
+ ReferenceEntrySet.prototype.addSymbol = function (sym) {
+ var unitIndex = sym.unitIndex;
+ if(unitIndex < 0) {
+ return;
+ }
+ var ast = sym.declAST;
+ if(ast == null) {
+ return;
+ }
+ var symbolLocation;
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.InterfaceDeclaration:
+ symbolLocation = (ast).name;
+ break;
+ case TypeScript.NodeType.ClassDeclaration:
+ symbolLocation = (ast).name;
+ break;
+ case TypeScript.NodeType.ModuleDeclaration:
+ symbolLocation = (ast).name;
+ break;
+ case TypeScript.NodeType.VarDecl:
+ symbolLocation = (ast).id;
+ break;
+ case TypeScript.NodeType.FuncDecl:
+ symbolLocation = (ast).name;
+ break;
+ default:
+ symbolLocation = ast;
+ }
+ if(symbolLocation === null) {
+ symbolLocation = ast;
+ }
+ this.addAst(unitIndex, symbolLocation, false);
+ };
+ return ReferenceEntrySet;
+ })();
+ Services.ReferenceEntrySet = ReferenceEntrySet;
+ var NavigateToItem = (function () {
+ function NavigateToItem() {
+ this.name = "";
+ this.kind = "";
+ this.kindModifiers = "";
+ this.matchKind = "";
+ this.unitIndex = -1;
+ this.minChar = -1;
+ this.limChar = -1;
+ this.containerName = "";
+ this.containerKind = "";
+ }
+ return NavigateToItem;
+ })();
+ Services.NavigateToItem = NavigateToItem;
+ var NavigateToContext = (function () {
+ function NavigateToContext() {
+ this.options = new TypeScript.AstWalkOptions();
+ this.unitIndex = 0;
+ this.containerSymbols = [];
+ this.containerKinds = [];
+ this.containerASTs = [];
+ this.path = new TypeScript.AstPath();
+ this.result = [];
+ }
+ return NavigateToContext;
+ })();
+ Services.NavigateToContext = NavigateToContext;
+ var TextRange = (function () {
+ function TextRange(minChar, limChar) {
+ this.minChar = minChar;
+ this.limChar = limChar;
+ }
+ return TextRange;
+ })();
+ Services.TextRange = TextRange;
+ var TextEdit = (function () {
+ function TextEdit(minChar, limChar, text) {
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.text = text;
+ }
+ TextEdit.createInsert = function createInsert(pos, text) {
+ return new TextEdit(pos, pos, text);
+ };
+ TextEdit.createDelete = function createDelete(minChar, limChar) {
+ return new TextEdit(minChar, limChar, "");
+ };
+ TextEdit.createReplace = function createReplace(minChar, limChar, text) {
+ return new TextEdit(minChar, limChar, text);
+ };
+ return TextEdit;
+ })();
+ Services.TextEdit = TextEdit;
+ var EditorOptions = (function () {
+ function EditorOptions() {
+ this.IndentSize = 4;
+ this.TabSize = 4;
+ this.NewLineCharacter = "\r\n";
+ this.ConvertTabsToSpaces = true;
+ }
+ return EditorOptions;
+ })();
+ Services.EditorOptions = EditorOptions;
+ var FormatCodeOptions = (function (_super) {
+ __extends(FormatCodeOptions, _super);
+ function FormatCodeOptions() {
+ _super.apply(this, arguments);
+
+ this.InsertSpaceAfterCommaDelimiter = true;
+ this.InsertSpaceAfterSemicolonInForStatements = true;
+ this.InsertSpaceBeforeAndAfterBinaryOperators = true;
+ this.InsertSpaceAfterKeywordsInControlFlowStatements = true;
+ this.InsertSpaceAfterFunctionKeywordForAnonymousFunctions = false;
+ this.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis = false;
+ this.PlaceOpenBraceOnNewLineForFunctions = false;
+ this.PlaceOpenBraceOnNewLineForControlBlocks = false;
+ }
+ return FormatCodeOptions;
+ })(EditorOptions);
+ Services.FormatCodeOptions = FormatCodeOptions;
+ var GetReferencesContext = (function () {
+ function GetReferencesContext() {
+ this.scope = [];
+ }
+ return GetReferencesContext;
+ })();
+ Services.GetReferencesContext = GetReferencesContext;
+ var DefinitionInfo = (function () {
+ function DefinitionInfo(unitIndex, minChar, limChar, kind, name, containerKind, containerName) {
+ this.unitIndex = unitIndex;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.kind = kind;
+ this.name = name;
+ this.containerKind = containerKind;
+ this.containerName = containerName;
+ }
+ return DefinitionInfo;
+ })();
+ Services.DefinitionInfo = DefinitionInfo;
+ var TypeInfo = (function () {
+ function TypeInfo(memberName, docComment, fullSymbolName, kind, minChar, limChar) {
+ this.memberName = memberName;
+ this.docComment = docComment;
+ this.fullSymbolName = fullSymbolName;
+ this.kind = kind;
+ this.minChar = minChar;
+ this.limChar = limChar;
+ }
+ return TypeInfo;
+ })();
+ Services.TypeInfo = TypeInfo;
+ var SpanInfo = (function () {
+ function SpanInfo(minChar, limChar, text) {
+ if (typeof text === "undefined") { text = null; }
+ this.minChar = minChar;
+ this.limChar = limChar;
+ this.text = text;
+ }
+ return SpanInfo;
+ })();
+ Services.SpanInfo = SpanInfo;
+ var SignatureInfo = (function () {
+ function SignatureInfo() { }
+ return SignatureInfo;
+ })();
+ Services.SignatureInfo = SignatureInfo;
+ var FormalSignatureInfo = (function () {
+ function FormalSignatureInfo() {
+ this.signatureGroup = [];
+ }
+ return FormalSignatureInfo;
+ })();
+ Services.FormalSignatureInfo = FormalSignatureInfo;
+ var FormalSignatureItemInfo = (function () {
+ function FormalSignatureItemInfo() {
+ this.parameters = [];
+ }
+ return FormalSignatureItemInfo;
+ })();
+ Services.FormalSignatureItemInfo = FormalSignatureItemInfo;
+ var FormalParameterInfo = (function () {
+ function FormalParameterInfo() { }
+ return FormalParameterInfo;
+ })();
+ Services.FormalParameterInfo = FormalParameterInfo;
+ var ActualSignatureInfo = (function () {
+ function ActualSignatureInfo() {
+ this.parameters = [];
+ }
+ return ActualSignatureInfo;
+ })();
+ Services.ActualSignatureInfo = ActualSignatureInfo;
+ var ActualParameterInfo = (function () {
+ function ActualParameterInfo() { }
+ return ActualParameterInfo;
+ })();
+ Services.ActualParameterInfo = ActualParameterInfo;
+ var CompletionInfo = (function () {
+ function CompletionInfo() {
+ this.maybeInaccurate = false;
+ this.isMemberCompletion = false;
+ this.entries = [];
+ }
+ return CompletionInfo;
+ })();
+ Services.CompletionInfo = CompletionInfo;
+ var CompletionEntry = (function () {
+ function CompletionEntry() {
+ this.name = "";
+ this.type = "";
+ this.kind = "";
+ this.kindModifiers = "";
+ this.fullSymbolName = "";
+ this.docComment = "";
+ }
+ return CompletionEntry;
+ })();
+ Services.CompletionEntry = CompletionEntry;
+ var ScriptElementKind = (function () {
+ function ScriptElementKind() { }
+ ScriptElementKind.unknown = "";
+ ScriptElementKind.keyword = "keyword";
+ ScriptElementKind.scriptElement = "script";
+ ScriptElementKind.moduleElement = "module";
+ ScriptElementKind.classElement = "class";
+ ScriptElementKind.interfaceElement = "interface";
+ ScriptElementKind.enumElement = "enum";
+ ScriptElementKind.variableElement = "var";
+ ScriptElementKind.localVariableElement = "local var";
+ ScriptElementKind.functionElement = "function";
+ ScriptElementKind.localFunctionElement = "local function";
+ ScriptElementKind.memberFunctionElement = "method";
+ ScriptElementKind.memberGetAccessorElement = "getter";
+ ScriptElementKind.memberSetAccessorElement = "setter";
+ ScriptElementKind.memberVariableElement = "property";
+ ScriptElementKind.constructorImplementationElement = "constructor";
+ ScriptElementKind.callSignatureElement = "call";
+ ScriptElementKind.indexSignatureElement = "index";
+ ScriptElementKind.constructSignatureElement = "construct";
+ ScriptElementKind.parameterElement = "parameter";
+ return ScriptElementKind;
+ })();
+ Services.ScriptElementKind = ScriptElementKind;
+ var ScriptElementKindModifier = (function () {
+ function ScriptElementKindModifier() { }
+ ScriptElementKindModifier.none = "";
+ ScriptElementKindModifier.publicMemberModifier = "public";
+ ScriptElementKindModifier.privateMemberModifier = "private";
+ ScriptElementKindModifier.exportedModifier = "export";
+ ScriptElementKindModifier.ambientModifier = "declare";
+ ScriptElementKindModifier.staticModifier = "static";
+ return ScriptElementKindModifier;
+ })();
+ Services.ScriptElementKindModifier = ScriptElementKindModifier;
+ var MatchKind = (function () {
+ function MatchKind() { }
+ MatchKind.none = null;
+ MatchKind.exact = "exact";
+ MatchKind.subString = "substring";
+ MatchKind.prefix = "prefix";
+ return MatchKind;
+ })();
+ Services.MatchKind = MatchKind;
+ var ScriptSyntaxASTState = (function () {
+ function ScriptSyntaxASTState() {
+ this.version = -1;
+ this.syntaxAST = null;
+ this.fileName = null;
+ }
+ return ScriptSyntaxASTState;
+ })();
+ Services.ScriptSyntaxASTState = ScriptSyntaxASTState;
+ var LanguageService = (function () {
+ function LanguageService(host) {
+ this.host = host;
+ this.logger = this.host;
+ this.compilerState = new Services.CompilerState(this.host);
+ this.syntaxASTState = new ScriptSyntaxASTState();
+ this.formattingRulesProvider = new Formatting.RulesProvider(this.logger);
+ }
+ LanguageService.prototype.refresh = function () {
+ var _this = this;
+ TypeScript.timeFunction(this.logger, "refresh()", function () {
+ _this.compilerState.refresh();
+ });
+ };
+ LanguageService.prototype.minimalRefresh = function () {
+ var _this = this;
+ TypeScript.timeFunction(this.logger, "minimalRefresh()", function () {
+ _this.compilerState.minimalRefresh();
+ });
+ };
+ LanguageService.prototype.getSymbolTree = function () {
+ this.refresh();
+ return this.compilerState.getSymbolTree();
+ };
+ LanguageService.prototype.getScriptSyntaxAST = function (fileName) {
+ this.minimalRefresh();
+ return this._getScriptSyntaxAST(fileName);
+ };
+ LanguageService.prototype._getScriptSyntaxAST = function (fileName) {
+ var _this = this;
+ return TypeScript.timeFunction(this.logger, "getScriptSyntaxAST(\"" + fileName + "\")", function () {
+ var version = _this.compilerState.getScriptVersion(fileName);
+ var syntaxAST = _this.syntaxASTState.syntaxAST;
+ if(syntaxAST === null || _this.syntaxASTState.fileName !== fileName) {
+ syntaxAST = _this.compilerState.getScriptSyntaxAST(fileName);
+ } else if(_this.syntaxASTState.version !== version) {
+ syntaxAST = _this.attemptIncrementalSyntaxAST(_this.syntaxASTState);
+ if(syntaxAST === null) {
+ syntaxAST = _this.compilerState.getScriptSyntaxAST(fileName);
+ }
+ }
+ _this.syntaxASTState.version = version;
+ _this.syntaxASTState.fileName = fileName;
+ _this.syntaxASTState.syntaxAST = syntaxAST;
+ return _this.syntaxASTState.syntaxAST;
+ });
+ };
+ LanguageService.prototype.attemptIncrementalSyntaxAST = function (syntaxASTState) {
+ var syntaxAST = syntaxASTState.syntaxAST;
+ var fileName = syntaxAST.getScriptId();
+ var newSourceText = this.compilerState.getSourceText2(fileName);
+ var editRange = this.compilerState.getScriptEditRangeSinceVersion(fileName, syntaxASTState.version);
+ if(editRange === null) {
+ return syntaxAST;
+ }
+ var incrementalParser = new TypeScript.IncrementalParser(this.logger);
+ var updateResult = incrementalParser.attemptIncrementalUpdateUnit(syntaxAST.getScript(), syntaxAST.getScriptId(), newSourceText, editRange);
+ if(updateResult !== null && updateResult.kind === TypeScript.UpdateUnitKind.EditsInsideSingleScope) {
+ incrementalParser.mergeTrees(updateResult);
+ return new Services.ScriptSyntaxAST(this.logger, updateResult.script1, newSourceText);
+ }
+ return null;
+ };
+ LanguageService.prototype.getScriptAST = function (fileName) {
+ this.refresh();
+ return this.compilerState.getScriptAST(fileName);
+ };
+ LanguageService.prototype.getTypeInfo = function (type, symbol, typeInfoAtPosition, enclosingScopeContext) {
+ var memberName = null;
+ var kind = "";
+ var docComment = "";
+ var symbolName = "";
+ var scopeSymbol = enclosingScopeContext.getScope();
+ if(typeInfoAtPosition.ast.nodeType == TypeScript.NodeType.Dot) {
+ return null;
+ }
+ if(symbol.declAST && symbol.declAST.nodeType == TypeScript.NodeType.FuncDecl && (symbol.declAST).accessorSymbol) {
+ symbol = (symbol.declAST).accessorSymbol;
+ type = symbol.getType();
+ }
+ if(typeInfoAtPosition.callSignature) {
+ var signatureGroup = null;
+ if(typeInfoAtPosition.isNew) {
+ signatureGroup = type.construct;
+ } else {
+ signatureGroup = type.call;
+ }
+ var memberNames = new TypeScript.MemberNameArray();
+ memberNames.addAll(signatureGroup.toStrings("", true, scopeSymbol, true, typeInfoAtPosition.callSignature));
+ memberName = memberNames;
+ if(typeInfoAtPosition.callSignature.declAST) {
+ docComment = TypeScript.Comment.getDocCommentText(typeInfoAtPosition.callSignature.declAST.getDocComments());
+ if(typeInfoAtPosition.callSignature.declAST.type.symbol.name != "_anonymous") {
+ symbol = typeInfoAtPosition.callSignature.declAST.type.symbol;
+ }
+ } else {
+ docComment = "";
+ }
+ kind = this.getSymbolElementKind(symbol, scopeSymbol, false);
+ if(kind == ScriptElementKind.interfaceElement || kind == ScriptElementKind.classElement) {
+ kind = typeInfoAtPosition.isNew ? ScriptElementKind.constructorImplementationElement : ScriptElementKind.functionElement;
+ }
+ } else {
+ memberName = type.getScopedTypeNameEx(scopeSymbol, true);
+ docComment = this.getDocCommentOfSymbol(symbol);
+ kind = this.getSymbolElementKind(symbol, scopeSymbol, true);
+ }
+ symbolName = symbol ? this.getFullNameOfSymbol(symbol, enclosingScopeContext) : "";
+ return new TypeInfo(memberName, docComment, symbolName, kind, typeInfoAtPosition.ast.minChar, typeInfoAtPosition.ast.limChar);
+ };
+ LanguageService.prototype.getTypeAtPosition = function (fileName, pos) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var sourceText = this.compilerState.getSourceText(script);
+ var typeInfo = this.getTypeInfoAtPosition(pos, script, true);
+ if(typeInfo == null) {
+ this.logger.log("No type found at the specified location.");
+ return null;
+ }
+ var enclosingScopeContext = TypeScript.findEnclosingScopeAt(this.logger, script, sourceText, pos, false);
+ if(enclosingScopeContext == null) {
+ this.logger.log("No context found at the specified location.");
+ return null;
+ }
+ if(typeInfo.symbol) {
+ return this.getTypeInfo(typeInfo.symbol.getType(), typeInfo.symbol, typeInfo, enclosingScopeContext);
+ } else if(typeInfo.ast.type) {
+ return this.getTypeInfo(typeInfo.ast.type, typeInfo.ast.type.symbol, typeInfo, enclosingScopeContext);
+ } else {
+ this.logger.log("No type found at the specified location.");
+ return null;
+ }
+ };
+ LanguageService.prototype.getNameOrDottedNameSpan = function (fileName, startPos, endPos) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var typeAndSpanInfo = this.getTypeInfoAtPosition(startPos, script);
+ if(typeAndSpanInfo == null) {
+ this.logger.log("No name or dotted name found at the specified location.");
+ return null;
+ }
+ return typeAndSpanInfo.spanInfo;
+ };
+ LanguageService.prototype.getBreakpointInStatement = function (pos, astSpan, verifyASTPos, existingResult, forceFirstStatement, isAst) {
+ if(existingResult || !astSpan || (verifyASTPos && pos > astSpan.limChar)) {
+ return existingResult;
+ }
+ if(!isAst) {
+ return astSpan;
+ }
+ var ast = astSpan;
+ var astList = null;
+ if(ast.nodeType == TypeScript.NodeType.Block) {
+ var block = ast;
+ astList = block.statements;
+ } else if(ast.nodeType == TypeScript.NodeType.List) {
+ astList = ast;
+ } else {
+ return ast;
+ }
+ if(astList.members.length > 0) {
+ var lastAST = astList.members[astList.members.length - 1];
+ if(!forceFirstStatement && pos > lastAST.limChar) {
+ return lastAST;
+ } else {
+ return astList.members[0];
+ }
+ }
+ return null;
+ };
+ LanguageService.prototype.getBreakpointStatementAtPosition = function (fileName, pos) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var containerASTs = [];
+ var lineMap = this.compilerState.getLineMap(fileName);
+ var lineCol = {
+ line: -1,
+ col: -1
+ };
+ TypeScript.getSourceLineColFromMap(lineCol, pos, lineMap);
+ var pre = function (cur, parent, walker) {
+ if(TypeScript.isValidAstNode(cur)) {
+ if(pos >= cur.minChar && pos <= cur.limChar) {
+ switch(cur.nodeType) {
+ case TypeScript.NodeType.ModuleDeclaration:
+ case TypeScript.NodeType.ClassDeclaration:
+ case TypeScript.NodeType.FuncDecl:
+ case TypeScript.NodeType.Break:
+ case TypeScript.NodeType.Continue:
+ containerASTs.push(cur);
+ break;
+ case TypeScript.NodeType.Script:
+ case TypeScript.NodeType.List:
+ case TypeScript.NodeType.NumberLit:
+ case TypeScript.NodeType.Regex:
+ case TypeScript.NodeType.QString:
+ case TypeScript.NodeType.ArrayLit:
+ case TypeScript.NodeType.ObjectLit:
+ case TypeScript.NodeType.TypeAssertion:
+ case TypeScript.NodeType.Pos:
+ case TypeScript.NodeType.Neg:
+ case TypeScript.NodeType.Not:
+ case TypeScript.NodeType.LogNot:
+ case TypeScript.NodeType.Block:
+ break;
+ case TypeScript.NodeType.TypeRef:
+ walker.options.goChildren = false;
+ break;
+ default:
+ if(cur.isStatementOrExpression() && (!cur.isExpression() || containerASTs.length == 0 || (!containerASTs[containerASTs.length - 1].isExpression() && containerASTs[containerASTs.length - 1].nodeType != TypeScript.NodeType.VarDecl || containerASTs[containerASTs.length - 1].nodeType == TypeScript.NodeType.ConditionalExpression))) {
+ containerASTs.push(cur);
+ }
+ break;
+ }
+ } else {
+ walker.options.goChildren = false;
+ }
+ }
+ return cur;
+ };
+ TypeScript.getAstWalkerFactory().walk(script, pre);
+ if(containerASTs.length == 0) {
+ return null;
+ }
+ var resultAST = null;
+ var cur = containerASTs[containerASTs.length - 1];
+ var customSpan = null;
+ switch(cur.nodeType) {
+ case TypeScript.NodeType.ModuleDeclaration:
+ var moduleDecl = cur;
+ if(containerASTs.length > 1) {
+ resultAST = moduleDecl;
+ } else {
+ resultAST = this.getBreakpointInStatement(pos, moduleDecl.members, false, null, false, true);
+ }
+ customSpan = moduleDecl.endingToken;
+ break;
+ case TypeScript.NodeType.FuncDecl:
+ var funcDecl = cur;
+ if(containerASTs.length > 1) {
+ resultAST = funcDecl;
+ } else {
+ resultAST = this.getBreakpointInStatement(pos, funcDecl.bod, false, null, false, true);
+ }
+ customSpan = funcDecl.endingToken;
+ break;
+ case TypeScript.NodeType.ClassDeclaration:
+ var classDecl = cur;
+ if(containerASTs.length > 1) {
+ resultAST = classDecl;
+ } else {
+ resultAST = this.getBreakpointInStatement(pos, classDecl.members, false, null, false, true);
+ }
+ customSpan = classDecl.endingToken;
+ break;
+ case TypeScript.NodeType.VarDecl:
+ var varDecl = cur;
+ if(varDecl.init) {
+ resultAST = varDecl;
+ }
+ break;
+ case TypeScript.NodeType.If:
+ var ifStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, ifStatement.statement, true, resultAST, false, false);
+ resultAST = this.getBreakpointInStatement(pos, ifStatement.thenBod, true, resultAST, false, true);
+ resultAST = this.getBreakpointInStatement(pos, ifStatement.elseBod, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.ForIn:
+ var forInStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, forInStatement.statement, true, resultAST, false, false);
+ resultAST = this.getBreakpointInStatement(pos, forInStatement.body, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.For:
+ var forStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, forStatement.init, true, null, false, true);
+ resultAST = this.getBreakpointInStatement(pos, forStatement.cond, true, resultAST, false, true);
+ resultAST = this.getBreakpointInStatement(pos, forStatement.incr, true, resultAST, false, true);
+ resultAST = this.getBreakpointInStatement(pos, forStatement.body, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.While:
+ var whileStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, whileStatement.cond, true, null, false, true);
+ resultAST = this.getBreakpointInStatement(pos, whileStatement.body, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.DoWhile:
+ var doWhileStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, doWhileStatement.body, true, null, false, true);
+ resultAST = this.getBreakpointInStatement(pos, doWhileStatement.cond, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.Switch:
+ var switchStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, switchStatement.statement, true, resultAST, false, false);
+ var caseListCount = switchStatement.caseList.members.length;
+ if(caseListCount > 0) {
+ var lastCase = switchStatement.caseList.members[caseListCount - 1];
+ if(pos >= lastCase.limChar) {
+ var caseToUse = lastCase;
+ resultAST = this.getBreakpointInStatement(pos, caseToUse.body.members[0], false, resultAST, false, true);
+ } else {
+ var caseToUse = switchStatement.caseList.members[0];
+ resultAST = this.getBreakpointInStatement(pos, caseToUse.body.members[0], false, resultAST, true, true);
+ }
+ }
+ break;
+ case TypeScript.NodeType.Case:
+ var caseStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, caseStatement.body.members[0], false, null, false, true);
+ break;
+ case TypeScript.NodeType.With:
+ var withStatement = cur;
+ resultAST = this.getBreakpointInStatement(pos, withStatement.body, false, null, false, true);
+ break;
+ case TypeScript.NodeType.Try:
+ var tryNode = cur;
+ resultAST = this.getBreakpointInStatement(pos, tryNode.body, false, null, false, true);
+ break;
+ case TypeScript.NodeType.Catch:
+ var catchNode = cur;
+ resultAST = this.getBreakpointInStatement(pos, catchNode.statement, true, null, false, false);
+ resultAST = this.getBreakpointInStatement(pos, catchNode.body, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.Finally:
+ var finallyNode = cur;
+ resultAST = this.getBreakpointInStatement(pos, finallyNode, false, null, false, true);
+ break;
+ case TypeScript.NodeType.TryCatch:
+ var tryCatch = cur;
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.tryNode.body, true, null, false, true);
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.catchNode.statement, true, resultAST, false, false);
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.catchNode.body, false, resultAST, false, true);
+ break;
+ case TypeScript.NodeType.TryFinally:
+ var tryFinally = cur;
+ if(tryFinally.nodeType == TypeScript.NodeType.Try) {
+ resultAST = this.getBreakpointInStatement(pos, (tryFinally.tryNode).body, true, null, false, true);
+ } else {
+ var tryCatch = tryFinally.tryNode;
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.tryNode.body, true, null, false, true);
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.catchNode.statement, true, resultAST, false, false);
+ resultAST = this.getBreakpointInStatement(pos, tryCatch.catchNode.body, true, resultAST, false, true);
+ }
+ resultAST = this.getBreakpointInStatement(pos, tryFinally.finallyNode, false, resultAST, false, true);
+ break;
+ default:
+ resultAST = cur;
+ break;
+ }
+ if(TypeScript.isValidAstNode(customSpan) && pos >= customSpan.minChar && pos <= customSpan.limChar) {
+ resultAST = customSpan;
+ }
+ if(resultAST) {
+ var result = new SpanInfo(resultAST.minChar, resultAST.limChar);
+ return result;
+ }
+ return null;
+ };
+ LanguageService.prototype.getSignatureAtPosition = function (fileName, pos) {
+ var _this = this;
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var atEOF = (pos === script.limChar);
+ var path = this.getAstPathToPosition(script, pos);
+ if(path.count() == 0) {
+ return null;
+ }
+ if(path.nodeType() === TypeScript.NodeType.Comment) {
+ this.logger.log("position is inside a comment");
+ return null;
+ }
+ var callExpr = null;
+ while(path.count() >= 2) {
+ if(path.isArgumentListOfCall() || path.isArgumentListOfNew()) {
+ if(atEOF || pos > path.ast().minChar) {
+ path.pop();
+ callExpr = path.pop();
+ }
+ break;
+ }
+ if(pos > path.ast().minChar) {
+ if(path.ast().nodeType !== TypeScript.NodeType.Error && path.ast().nodeType !== TypeScript.NodeType.List) {
+ break;
+ }
+ }
+ path.pop();
+ }
+ if(!callExpr || !callExpr.target || !callExpr.target.type) {
+ this.logger.log("No call expression for the given position");
+ return null;
+ }
+ if(callExpr.target.type === this.compilerState.anyType()) {
+ this.logger.log("Call expression is of type 'any'");
+ return null;
+ }
+ var sourceText = this.compilerState.getSourceText(script);
+ var enclosingScopeContext = TypeScript.findEnclosingScopeAt(this.logger, script, sourceText, pos, false);
+ if(enclosingScopeContext == null) {
+ this.logger.log("No context found at the specified location.");
+ return null;
+ }
+ var getNameFromSymbol = function (symbol) {
+ if(symbol != null && symbol.name != "_anonymous") {
+ return symbol.name;
+ }
+ return "";
+ };
+ var getDocCommentFromSymbol = function (symbol) {
+ if(symbol != null) {
+ return TypeScript.Comment.getDocCommentText(symbol.getDocComments());
+ }
+ return "";
+ };
+ var convertSignatureGroupToSignatureInfo = function (symbol, isNew, group) {
+ var result = new FormalSignatureInfo();
+ result.isNew = false;
+ result.name = getNameFromSymbol(symbol);
+ result.docComment = getDocCommentFromSymbol(symbol);
+ result.openParen = (group.flags & TypeScript.SignatureFlags.IsIndexer ? "[" : "(");
+ result.closeParen = (group.flags & TypeScript.SignatureFlags.IsIndexer ? "]" : ")");
+ var hasOverloads = group.signatures.length > 1;
+ group.signatures.filter(function (signature) {
+ return !(hasOverloads && signature === group.definitionSignature && !_this.compilerState.getCompilationSettings().canCallDefinitionSignature);
+ }).forEach(function (signature) {
+ var signatureGroupInfo = new FormalSignatureItemInfo();
+ signatureGroupInfo.docComment = (signature.declAST != null) ? TypeScript.Comment.getDocCommentText(signature.declAST.getDocComments()) : "";
+ signatureGroupInfo.returnType = (signature.returnType === null ? "any" : signature.returnType.type.getScopedTypeName(enclosingScopeContext.getScope()));
+ signature.parameters.forEach(function (p, i) {
+ var signatureParameterInfo = new FormalParameterInfo();
+ signatureParameterInfo.isVariable = (signature.hasVariableArgList) && (i === signature.parameters.length - 1);
+ signatureParameterInfo.isOptional = p.isOptional();
+ signatureParameterInfo.name = p.name;
+ signatureParameterInfo.docComment = p.getParameterDocComments();
+ signatureParameterInfo.type = p.getType().getScopedTypeName(enclosingScopeContext.getScope());
+ signatureGroupInfo.parameters.push(signatureParameterInfo);
+ });
+ result.signatureGroup.push(signatureGroupInfo);
+ });
+ return result;
+ };
+ var convertCallExprToActualSignatureInfo = function (ast, caretPosition) {
+ if(!TypeScript.isValidAstNode(ast)) {
+ return null;
+ }
+ if(!TypeScript.isValidAstNode(ast.arguments)) {
+ return null;
+ }
+ var result = new ActualSignatureInfo();
+ result.currentParameter = -1;
+ result.openParenMinChar = ast.arguments.minChar;
+ result.closeParenLimChar = Math.max(ast.arguments.minChar, ast.arguments.limChar);
+ ast.arguments.members.forEach(function (arg, index) {
+ var parameter = new ActualParameterInfo();
+ parameter.minChar = arg.minChar;
+ parameter.limChar = Math.max(arg.minChar, arg.limChar);
+ result.parameters.push(parameter);
+ });
+ result.parameters.forEach(function (p, index) {
+ var minChar = (index == 0 ? result.openParenMinChar : result.parameters[index - 1].limChar + 1);
+ var limChar = (index == result.parameters.length - 1 ? result.closeParenLimChar : result.parameters[index + 1].minChar);
+ if(caretPosition >= minChar && (atEOF ? caretPosition <= limChar : caretPosition < limChar)) {
+ result.currentParameter = index;
+ }
+ });
+ return result;
+ };
+ var getSignatureIndex = function (ast, group) {
+ if(ast == null || group == null || group.signatures == null) {
+ return -1;
+ }
+ return group.signatures.indexOf(ast.signature);
+ };
+ var getTargetSymbolWithName = function (callExpr) {
+ var sym = null;
+ if((callExpr.target).sym != null) {
+ sym = (callExpr.target).sym;
+ } else if(callExpr.target.type.symbol !== null) {
+ var sym = callExpr.target.type.symbol;
+ }
+ if(sym != null) {
+ if(sym.kind() == TypeScript.SymbolKind.Type && ((sym).isMethod || (sym).isClass() || (sym).isFunction()) && (sym.name != null)) {
+ return sym;
+ } else if(sym.kind() == TypeScript.SymbolKind.Parameter) {
+ return sym;
+ } else if(sym.kind() == TypeScript.SymbolKind.Variable) {
+ return sym;
+ } else if(sym.kind() == TypeScript.SymbolKind.Field) {
+ return sym;
+ }
+ }
+ return null;
+ };
+ var symbol = getTargetSymbolWithName(callExpr);
+ var result = new SignatureInfo();
+ if(callExpr.nodeType === TypeScript.NodeType.Call && callExpr.target.type.call !== null) {
+ result.formal = convertSignatureGroupToSignatureInfo(symbol, false, callExpr.target.type.call);
+ result.actual = convertCallExprToActualSignatureInfo(callExpr, pos);
+ result.activeFormal = getSignatureIndex(callExpr, callExpr.target.type.call);
+ } else if(callExpr.nodeType === TypeScript.NodeType.New && callExpr.target.type.construct !== null) {
+ result.formal = convertSignatureGroupToSignatureInfo(symbol, true, callExpr.target.type.construct);
+ result.actual = convertCallExprToActualSignatureInfo(callExpr, pos);
+ result.activeFormal = getSignatureIndex(callExpr, callExpr.target.type.construct);
+ } else if(callExpr.target.nodeType === TypeScript.NodeType.Super && callExpr.target.type.symbol && callExpr.target.type.symbol.declAST) {
+ var classType = callExpr.target.type.symbol.declAST.type;
+ if(classType && classType.construct !== null) {
+ result.formal = convertSignatureGroupToSignatureInfo(symbol, true, classType.construct);
+ result.actual = convertCallExprToActualSignatureInfo(callExpr, pos);
+ result.activeFormal = getSignatureIndex(callExpr, classType.construct);
+ } else {
+ this.logger.log("No signature group found for the target class type constructor");
+ return null;
+ }
+ } else {
+ this.logger.log("No signature group found for the target of the call expression");
+ return null;
+ }
+ if(result.actual == null || result.formal == null || result.activeFormal == null) {
+ this.logger.log("Can't compute actual and/or formal signature of the call expression");
+ return null;
+ }
+ return result;
+ };
+ LanguageService.prototype.getDefinitionAtPosition = function (fileName, pos) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var sym = this.getSymbolAtPosition(script, pos);
+ if(sym == null) {
+ this.logger.log("No identifier at the specified location.");
+ return null;
+ }
+ if(!TypeScript.isValidAstNode(sym.declAST)) {
+ this.logger.log("No symbol location for identifier at the specified location.");
+ return null;
+ }
+ var unitIndex = sym.unitIndex;
+ var minChar = sym.declAST.minChar;
+ var limChar = sym.declAST.limChar;
+ return new DefinitionInfo(this.compilerState.mapToHostUnitIndex(unitIndex), minChar, limChar, this.getSymbolElementKind(sym), sym.name, this.getSymbolContainerKind(sym), this.getSymbolContainerName(sym));
+ };
+ LanguageService.prototype.getSmartIndentAtLineNumber = function (fileName, lineNumber, options) {
+ this.minimalRefresh();
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.SmartIndentManager(syntaxAST, options);
+ return manager.getSmartIndentAtLineNumber(lineNumber);
+ };
+ LanguageService.prototype.getBraceMatchingAtPosition = function (fileName, position) {
+ this.minimalRefresh();
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Services.BraceMatchingManager(syntaxAST);
+ return manager.getBraceMatchingAtPosition(position);
+ };
+ LanguageService.prototype.getFullNameOfSymbol = function (symbol, enclosingScopeContext) {
+ if(symbol && symbol.container && symbol.container.declAST && symbol.container.declAST.nodeType == TypeScript.NodeType.FuncDecl) {
+ var funcDecl = symbol.container.declAST;
+ if(funcDecl.symbols.lookup(symbol.name) == symbol) {
+ return symbol.getPrettyName(enclosingScopeContext.getScope().container);
+ }
+ }
+ if(symbol && symbol.kind() == TypeScript.SymbolKind.Type) {
+ var typeSymbol = symbol;
+ if(typeSymbol.type && typeSymbol.type.symbol == symbol && typeSymbol.type.primitiveTypeClass != TypeScript.Primitive.None) {
+ return "";
+ }
+ }
+ return symbol.fullName(enclosingScopeContext.getScope());
+ };
+ LanguageService.prototype.getSymbolElementKind = function (sym, scopeSymbol, useConstructorAsClass) {
+ if(!sym) {
+ return ScriptElementKind.unknown;
+ }
+ if(sym.declAST == null) {
+ return ScriptElementKind.keyword;
+ }
+ var isLocal = function () {
+ if(sym.container && sym.container.declAST && sym.container.declAST.nodeType == TypeScript.NodeType.FuncDecl) {
+ if(scopeSymbol && scopeSymbol.container == sym.container) {
+ return true;
+ }
+ }
+ return false;
+ };
+ var ast = sym.declAST;
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.InterfaceDeclaration:
+ return ScriptElementKind.interfaceElement;
+ case TypeScript.NodeType.ClassDeclaration:
+ return ScriptElementKind.classElement;
+ case TypeScript.NodeType.ModuleDeclaration:
+ var moduleDecl = ast;
+ var isEnum = moduleDecl.isEnum();
+ return isEnum ? ScriptElementKind.enumElement : ScriptElementKind.moduleElement;
+ case TypeScript.NodeType.ImportDeclaration:
+ return ScriptElementKind.moduleElement;
+ case TypeScript.NodeType.VarDecl:
+ var varDecl = ast;
+ if(varDecl.isProperty()) {
+ return ScriptElementKind.memberVariableElement;
+ }
+ return isLocal() ? ScriptElementKind.localVariableElement : ScriptElementKind.variableElement;
+ case TypeScript.NodeType.ArgDecl:
+ var argDecl = ast;
+ if(sym.kind() == TypeScript.SymbolKind.Parameter) {
+ return ScriptElementKind.parameterElement;
+ }
+ return (argDecl.isProperty() ? ScriptElementKind.memberVariableElement : ScriptElementKind.variableElement);
+ case TypeScript.NodeType.FuncDecl:
+ var funcDecl = ast;
+ if(funcDecl.isGetAccessor()) {
+ return ScriptElementKind.memberGetAccessorElement;
+ } else if(funcDecl.isSetAccessor()) {
+ return ScriptElementKind.memberSetAccessorElement;
+ } else if(funcDecl.isCallMember()) {
+ return ScriptElementKind.callSignatureElement;
+ } else if(funcDecl.isIndexerMember()) {
+ return ScriptElementKind.indexSignatureElement;
+ } else if(funcDecl.isConstructMember()) {
+ return ScriptElementKind.constructSignatureElement;
+ } else if(funcDecl.isConstructor) {
+ return useConstructorAsClass ? ScriptElementKind.classElement : ScriptElementKind.constructorImplementationElement;
+ } else if(funcDecl.isMethod()) {
+ return ScriptElementKind.memberFunctionElement;
+ } else if(isLocal()) {
+ return ScriptElementKind.localFunctionElement;
+ } else {
+ return ScriptElementKind.functionElement;
+ }
+ default:
+ if(this.logger.warning()) {
+ this.logger.log("Warning: unrecognized AST node type: " + (TypeScript.NodeType)._map[ast.nodeType]);
+ }
+ return ScriptElementKind.unknown;
+ }
+ };
+ LanguageService.prototype.getSymbolElementKindModifiers = function (sym) {
+ if(sym.declAST == null) {
+ return ScriptElementKindModifier.none;
+ }
+ return this.getDeclNodeElementKindModifiers(sym.declAST);
+ };
+ LanguageService.prototype.getSymbolContainerKind = function (sym) {
+ return "";
+ };
+ LanguageService.prototype.getSymbolContainerName = function (sym) {
+ return sym.container == null ? "" : sym.container.fullName();
+ };
+ LanguageService.prototype.getReferencesAtPosition = function (fileName, pos) {
+ this.refresh();
+ var context = new GetReferencesContext();
+ for(var i = 0, len = this.compilerState.getScriptCount(); i < len; i++) {
+ context.scope.push(i);
+ }
+ return this.getReferencesForSourceLocation(context, this.compilerState.getUnitIndex(fileName), pos);
+ };
+ LanguageService.prototype.getOccurrencesAtPosition = function (fileName, pos) {
+ this.refresh();
+ var unitIndex = this.compilerState.getUnitIndex(fileName);
+ var context = new GetReferencesContext();
+ context.scope.push(unitIndex);
+ return this.getReferencesForSourceLocation(context, unitIndex, pos);
+ };
+ LanguageService.prototype.getImplementorsAtPosition = function (fileName, position) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var path = this.getIdentifierPathToPosition(script, position);
+ if(path === null) {
+ this.logger.log("No identifier at the specified location.");
+ return [];
+ }
+ var name = path.ast();
+ var sym = name.sym;
+ if(sym === null) {
+ this.logger.log("No symbol annotation on the identifier AST.");
+ return [];
+ }
+ var collector = new Services.OverridesCollector(this.getSymbolTree());
+ var symbolSet = collector.findImplementors(sym);
+ var references = new ReferenceEntrySet();
+ symbolSet.getAll().forEach(function (x) {
+ references.addSymbol(x);
+ });
+ return this.mapUnitIndexInReferenceEntrySet(references);
+ };
+ LanguageService.prototype.getReferencesForSourceLocation = function (context, unitIndex, position) {
+ var script = this.compilerState.getScript(unitIndex);
+ var path = this.getIdentifierPathToPosition(script, position);
+ if(path === null) {
+ this.logger.log("No identifier at the specified location.");
+ return [];
+ }
+ var name = path.ast();
+ var sym = name.sym;
+ if(sym === null) {
+ this.logger.log("No symbol annotation on the identifier AST.");
+ return [];
+ }
+ return this.getReferencesForSymbol(context, sym);
+ };
+ LanguageService.prototype.isWriteAccess = function (parent, cur) {
+ var write = false;
+ if(parent !== null) {
+ var pnt = parent.nodeType;
+ switch(pnt) {
+ case TypeScript.NodeType.VarDecl:
+ if((parent).init != null) {
+ write = true;
+ }
+ break;
+ case TypeScript.NodeType.ArgDecl:
+ write = true;
+ break;
+ case TypeScript.NodeType.Asg:
+ 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:
+ case TypeScript.NodeType.AsgXor:
+ case TypeScript.NodeType.AsgLsh:
+ case TypeScript.NodeType.AsgRsh:
+ case TypeScript.NodeType.AsgRs2:
+ if((parent).operand1 === cur) {
+ write = true;
+ }
+ break;
+ case TypeScript.NodeType.IncPost:
+ case TypeScript.NodeType.IncPre:
+ case TypeScript.NodeType.DecPost:
+ case TypeScript.NodeType.DecPre:
+ write = true;
+ break;
+ }
+ }
+ return write;
+ };
+ LanguageService.prototype.getReferencesForSymbol = function (context, sym) {
+ var _this = this;
+ var collector = new Services.OverridesCollector(this.getSymbolTree());
+ var symbolSet = collector.findMemberOverrides(sym);
+ var references = new ReferenceEntrySet();
+ var match = function (unitIndex, parent, cur) {
+ references.addAst(unitIndex, cur, _this.isWriteAccess(parent, cur));
+ };
+ if(sym.kind() == TypeScript.SymbolKind.Field) {
+ this.logger.log("getReferencesToField");
+ this.getReferencesToField(context, symbolSet, match);
+ } else if(sym.kind() == TypeScript.SymbolKind.Parameter) {
+ this.logger.log("getReferencesToParameter");
+ this.getReferencesToParameter(context, symbolSet, match);
+ } else if(sym.kind() == TypeScript.SymbolKind.Type) {
+ this.logger.log("getReferencesToType");
+ this.getReferencesToType(context, symbolSet, match);
+ } else if(sym.kind() == TypeScript.SymbolKind.Variable) {
+ this.logger.log("getReferencesToVariable");
+ this.getReferencesToVariable(context, symbolSet, match);
+ } else {
+ this.logger.log("No recognized symbol at the specified location (" + sym.kind() + ").");
+ }
+ return this.mapUnitIndexInReferenceEntrySet(references);
+ };
+ LanguageService.prototype.mapUnitIndexInReferenceEntrySet = function (references) {
+ var _this = this;
+ var result = references.getEntries();
+ result.forEach(function (x) {
+ x.unitIndex = _this.compilerState.mapToHostUnitIndex(x.unitIndex);
+ });
+ return result;
+ };
+ LanguageService.prototype.getCompletionsAtPosition = function (fileName, pos, isMemberCompletion) {
+ this.refresh();
+ var result = this.getQuickCompletionsAtPosition(fileName, pos, isMemberCompletion);
+ if(result == null) {
+ this.refresh();
+ result = this.getAccurateCompletionsAtPosition(fileName, pos, isMemberCompletion);
+ }
+ return result;
+ };
+ LanguageService.prototype.getQuickCompletionsAtPosition = function (fileName, pos, isMemberCompletion) {
+ var script = this.compilerState.getScriptAST(fileName);
+ var editRange = this.compilerState.getScriptEditRange(script);
+ if(editRange == null) {
+ this.logger.log("Full refresh required: there are no pending edits for the script. Be conservative and try again with accurate algorithm.");
+ return null;
+ }
+ var sourceText = this.compilerState.getSourceText(script);
+ var enclosingScopeContext = new TypeScript.IncrementalParser(this.logger).getEnclosingScopeContextIfSingleScopeEdit(script, fileName, sourceText, editRange);
+ if(enclosingScopeContext === null) {
+ this.logger.log("Full refresh required: range of edits may affect more than one scope");
+ return null;
+ }
+ if(enclosingScopeContext.enclosingObjectLit !== null) {
+ this.logger.log("Full refresh required: quick completion list does not work inside object literals, because full typecheck is required to obtain the target type of the object literal.");
+ return null;
+ }
+ enclosingScopeContext.pos = pos;
+ enclosingScopeContext.isMemberCompletion = isMemberCompletion;
+ this.logger.log("Found scope context in previous script AST: " + editRange + ", pos=" + pos + ", scopePos=" + enclosingScopeContext.getScopePosition());
+ var result = new CompletionInfo();
+ result.maybeInaccurate = true;
+ result.isMemberCompletion = isMemberCompletion;
+ enclosingScopeContext.useFullAst = false;
+ this.getCompletionsFromEnclosingScopeContext(enclosingScopeContext, result);
+ if(result.entries.length == 0) {
+ this.logger.log("Full refresh required: QuickCompletion returned an empty list. Be conservative and try again with accurate algorithm.");
+ return null;
+ }
+ return result;
+ };
+ LanguageService.prototype.getAccurateCompletionsAtPosition = function (fileName, pos, isMemberCompletion) {
+ var result = new CompletionInfo();
+ result.maybeInaccurate = false;
+ result.isMemberCompletion = isMemberCompletion;
+ var script = this.compilerState.getScriptAST(fileName);
+ var sourceText = this.compilerState.getSourceText(script);
+ var enclosingScopeContext = TypeScript.findEnclosingScopeAt(this.logger, script, sourceText, pos, isMemberCompletion);
+ if(enclosingScopeContext == null) {
+ this.logger.log("No context found at the specified location.");
+ return result;
+ }
+ this.logger.log("Found scope context in up-to-date script AST: pos=" + pos + ", scopePos=" + enclosingScopeContext.getScopePosition());
+ enclosingScopeContext.useFullAst = true;
+ this.getCompletionsFromEnclosingScopeContext(enclosingScopeContext, result);
+ return result;
+ };
+ LanguageService.prototype.getDocCommentOfSymbol = function (symbol) {
+ if(!symbol) {
+ return "";
+ }
+ var type = symbol.getType();
+ if(type && type.isClass() && type.symbol.name == symbol.name) {
+ return TypeScript.Comment.getDocCommentText(type.getDocComments());
+ }
+ if(symbol.declAST && symbol.declAST.nodeType == TypeScript.NodeType.FuncDecl && type.call && type.call.signatures.length > 1) {
+ return TypeScript.Comment.getDocCommentFirstOverloadSignature(type.call);
+ }
+ if(symbol.kind() == TypeScript.SymbolKind.Parameter) {
+ return (symbol).getParameterDocComments();
+ }
+ if(symbol.declAST && symbol.declAST.nodeType == TypeScript.NodeType.ArgDecl && (symbol.declAST).isProperty()) {
+ return ((symbol.declAST).sym).getParameterDocComments();
+ }
+ return TypeScript.Comment.getDocCommentText(symbol.getDocComments());
+ };
+ LanguageService.prototype.getCompletionsFromEnclosingScopeContext = function (enclosingScopeContext, result) {
+ var _this = this;
+ var getCompletions = function (isMemberCompletion) {
+ result.isMemberCompletion = isMemberCompletion;
+ enclosingScopeContext.isMemberCompletion = isMemberCompletion;
+ var entries = _this.compilerState.getScopeEntries(enclosingScopeContext, true);
+ entries.forEach(function (x) {
+ var entry = new CompletionEntry();
+ entry.name = x.name;
+ entry.type = x.type;
+ entry.kind = _this.getSymbolElementKind(x.sym, enclosingScopeContext.getScope(), true);
+ entry.fullSymbolName = _this.getFullNameOfSymbol(x.sym, enclosingScopeContext);
+ entry.docComment = _this.getDocCommentOfSymbol(x.sym);
+ entry.kindModifiers = _this.getSymbolElementKindModifiers(x.sym);
+ result.entries.push(entry);
+ });
+ };
+ var scriptFragment = enclosingScopeContext.getScriptFragment();
+ try {
+ var path = this.getAstPathToPosition(scriptFragment, enclosingScopeContext.pos - enclosingScopeContext.getScriptFragmentPosition(), TypeScript.GetAstPathOptions.EdgeInclusive | TypeScript.GetAstPathOptions.DontPruneSearchBasedOnPosition);
+ if(this.isCompletionListBlocker(path)) {
+ this.logger.log("Returning an empty list because position is inside a comment");
+ } else if(this.isObjectLiteralMemberNameCompletion(enclosingScopeContext)) {
+ this.logger.log("Completion list for members of object literal");
+ return getCompletions(true);
+ } else if(enclosingScopeContext.isMemberCompletion || this.isCompletionListTriggerPoint(path)) {
+ return getCompletions(enclosingScopeContext.isMemberCompletion);
+ } else {
+ this.logger.log("Returning an empty list because position is not a valid position for displaying a completion list");
+ }
+ }finally {
+ this.compilerState.cleanASTTypesForReTypeCheck(scriptFragment);
+ }
+ };
+ LanguageService.prototype.isObjectLiteralMemberNameCompletion = function (enclosingScopeContext) {
+ if(enclosingScopeContext.enclosingObjectLit === null) {
+ return false;
+ }
+ if(enclosingScopeContext.isMemberCompletion) {
+ return false;
+ }
+ var objectLit = enclosingScopeContext.enclosingObjectLit;
+ var script = enclosingScopeContext.script;
+ var pos = enclosingScopeContext.pos;
+ if(!TypeScript.isValidAstNode(objectLit)) {
+ return false;
+ }
+ if(!TypeScript.isValidAstNode(objectLit.operand)) {
+ return false;
+ }
+ if(objectLit.operand.nodeType !== TypeScript.NodeType.List) {
+ return false;
+ }
+ var memberList = objectLit.operand;
+ var isInsideList = (memberList.minChar < pos && pos < memberList.limChar);
+ if(!isInsideList) {
+ return false;
+ }
+ if(memberList.members.length == 0) {
+ return true;
+ }
+ var syntaxAST = new Services.ScriptSyntaxAST(this.logger, script, enclosingScopeContext.text);
+ var tokenStream = new Services.TokenStreamHelper(syntaxAST.getTokenStream(memberList.minChar, memberList.limChar));
+ var nameAreaMinChar = tokenStream.tokenEndPos();
+ var isNameArea = false;
+ var cancelSearch = false;
+ if(!tokenStream.expect(TypeScript.TokenID.OpenBrace)) {
+ return false;
+ }
+ memberList.members.forEach(function (x, i) {
+ if(cancelSearch) {
+ return;
+ }
+ if(x.nodeType !== TypeScript.NodeType.Member) {
+ nameAreaMinChar = -1;
+ return;
+ }
+ var member = x;
+ if(!TypeScript.isValidAstNode(member.operand1)) {
+ nameAreaMinChar = -1;
+ return;
+ }
+ if(nameAreaMinChar < 0) {
+ nameAreaMinChar = member.operand1.minChar;
+ }
+ if(!tokenStream.skipToOffset(member.operand1.limChar)) {
+ nameAreaMinChar = -1;
+ cancelSearch = true;
+ return;
+ }
+ if(tokenStream.tokenId() !== TypeScript.TokenID.Colon) {
+ nameAreaMinChar = -1;
+ return;
+ }
+ if((nameAreaMinChar) >= 0 && (nameAreaMinChar <= pos) && (pos <= tokenStream.tokenStartPos())) {
+ isNameArea = true;
+ cancelSearch = true;
+ return;
+ }
+ nameAreaMinChar = -1;
+ if(TypeScript.isValidAstNode(member.operand2)) {
+ if(tokenStream.skipToOffset(member.operand2.limChar)) {
+ if(tokenStream.tokenId() == TypeScript.TokenID.Comma) {
+ nameAreaMinChar = tokenStream.tokenEndPos();
+ tokenStream.moveNext();
+ }
+ }
+ }
+ });
+ if(nameAreaMinChar < 0) {
+ return false;
+ }
+ if(isNameArea) {
+ return true;
+ }
+ if(tokenStream.tokenId() !== TypeScript.TokenID.CloseBrace) {
+ return false;
+ }
+ return (nameAreaMinChar <= pos) && (pos <= tokenStream.tokenStartPos());
+ };
+ LanguageService.prototype.isCompletionListBlocker = function (path) {
+ var asts = path.asts;
+ var isNodeType = function (nodeType) {
+ return (path.count() >= 1) && (path.ast().nodeType === nodeType);
+ };
+ if(isNodeType(TypeScript.NodeType.Comment) || isNodeType(TypeScript.NodeType.Regex) || isNodeType(TypeScript.NodeType.QString)) {
+ return true;
+ }
+ return false;
+ };
+ LanguageService.prototype.isCompletionListTriggerPoint = function (path) {
+ var asts = path.asts;
+ var isNodeType = function (nodeType) {
+ return (path.count() >= 1) && (path.ast().nodeType === nodeType);
+ };
+ var isDecl = function (nodeType) {
+ if(isNodeType(nodeType)) {
+ return true;
+ }
+ if(asts.length > 1 && (asts[asts.length - 2].nodeType === nodeType) && (asts[asts.length - 1].nodeType === TypeScript.NodeType.Name)) {
+ return true;
+ }
+ return false;
+ };
+ if(path.isNameOfVariable() || path.isNameOfFunction() || path.isNameOfArgument() || path.isArgumentListOfFunction() || path.isNameOfInterface() || path.isNameOfClass() || path.isNameOfModule()) {
+ return false;
+ }
+ if(isNodeType(TypeScript.NodeType.Member) || isNodeType(TypeScript.NodeType.TryCatch) || isNodeType(TypeScript.NodeType.Catch) || isNodeType(TypeScript.NodeType.Comment) || isNodeType(TypeScript.NodeType.Regex) || isNodeType(TypeScript.NodeType.QString)) {
+ return false;
+ }
+ return true;
+ };
+ LanguageService.prototype.getFormattingEditsForRange = function (fileName, minChar, limChar, options) {
+ this.minimalRefresh();
+ this.formattingRulesProvider.ensureUptodate(options);
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ var result = manager.FormatSelection(minChar, limChar);
+ if(this.logger.information()) {
+ this.logFormatCodeOptions(options);
+ this.logEditResults(syntaxAST, result);
+ }
+ return result;
+ };
+ LanguageService.prototype.getFormattingEditsForDocument = function (fileName, minChar, limChar, options) {
+ this.minimalRefresh();
+ this.formattingRulesProvider.ensureUptodate(options);
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ var result = manager.FormatDocument(minChar, limChar);
+ if(this.logger.information()) {
+ this.logEditResults(syntaxAST, result);
+ }
+ return result;
+ };
+ LanguageService.prototype.getFormattingEditsOnPaste = function (fileName, minChar, limChar, options) {
+ this.minimalRefresh();
+ this.formattingRulesProvider.ensureUptodate(options);
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ var result = manager.FormatOnPaste(minChar, limChar);
+ if(this.logger.information()) {
+ this.logEditResults(syntaxAST, result);
+ }
+ return result;
+ };
+ LanguageService.prototype.getFormattingEditsAfterKeystroke = function (fileName, position, key, options) {
+ this.minimalRefresh();
+ this.formattingRulesProvider.ensureUptodate(options);
+ if(key === "}") {
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ return manager.FormatOnClosingCurlyBrace(position);
+ } else if(key === ";") {
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ return manager.FormatOnSemicolon(position);
+ } else if(key === "\n") {
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ var manager = new Formatting.FormattingManager(syntaxAST, this.formattingRulesProvider, options);
+ return manager.FormatOnEnter(position);
+ }
+ return [];
+ };
+ LanguageService.prototype.getNavigateToItems = function (searchValue) {
+ this.refresh();
+ var terms = searchValue.split(" ");
+ for(var i = 0; i < terms.length; i++) {
+ terms[i] = terms[i].trim().toLocaleLowerCase();
+ }
+ var match = function (ast, parent, name) {
+ name = name.toLocaleLowerCase();
+ for(var i = 0; i < terms.length; i++) {
+ var term = terms[i];
+ if(name === term) {
+ return MatchKind.exact;
+ }
+ if(name.indexOf(term) == 0) {
+ return MatchKind.prefix;
+ }
+ if(name.indexOf(term) > 0) {
+ return MatchKind.subString;
+ }
+ }
+ return null;
+ };
+ var result = [];
+ for(var i = 0, len = this.compilerState.getScriptCount(); i < len; i++) {
+ var script = this.compilerState.getScript(i);
+ var scriptId = script.locationInfo.filename;
+ var matchKind = match(null, script, scriptId);
+ if(matchKind != null) {
+ var item = new NavigateToItem();
+ item.name = scriptId;
+ item.matchKind = matchKind;
+ item.kind = ScriptElementKind.scriptElement;
+ item.unitIndex = this.compilerState.mapToHostUnitIndex(i);
+ item.minChar = script.minChar;
+ item.limChar = script.limChar;
+ result.push(item);
+ }
+ var items = this.getASTItems(i, script, match);
+ for(var j = 0; j < items.length; j++) {
+ result.push(items[j]);
+ }
+ }
+ return result;
+ };
+ LanguageService.prototype.getScriptLexicalStructure = function (fileName) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ return this.getASTItems(script.locationInfo.unitIndex, script, function (name) {
+ return MatchKind.exact;
+ });
+ };
+ LanguageService.prototype.getOutliningRegions = function (fileName) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ var maxLim = function (current) {
+ var asts = [];
+ for (var _i = 0; _i < (arguments.length - 1); _i++) {
+ asts[_i] = arguments[_i + 1];
+ }
+ var maxLim1 = function (current, asts) {
+ var result = current;
+ for(var i = 0; i < asts.length; i++) {
+ var ast = asts[i];
+ if(ast != null && ast.limChar != 0 && ast.limChar > result) {
+ result = ast.limChar;
+ }
+ }
+ return result;
+ };
+ var result = maxLim1(current, asts);
+ for(var i = 0; i < asts.length; i++) {
+ var ast = asts[i];
+ if(ast != null && ast.nodeType == TypeScript.NodeType.List) {
+ result = maxLim1(result, (ast).members);
+ }
+ }
+ return result;
+ };
+ var findMinChar = function (parent, ast) {
+ var result = ast.minChar;
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.FuncDecl:
+ result = maxLim(result, (ast).name, (ast).arguments, (ast).returnTypeAnnotation);
+ break;
+ case TypeScript.NodeType.ModuleDeclaration:
+ result = maxLim(result, (ast).name);
+ break;
+ case TypeScript.NodeType.ClassDeclaration:
+ result = maxLim(result, (ast).name, (ast).extendsList, (ast).implementsList);
+ break;
+ case TypeScript.NodeType.InterfaceDeclaration:
+ result = maxLim(result, (ast).name, (ast).extendsList, (ast).implementsList);
+ break;
+ }
+ return result;
+ };
+ var findLimChar = function (parent, ast) {
+ return ast.limChar;
+ };
+ var match = function (parent, ast, name) {
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.FuncDecl:
+ if((ast).bod == null) {
+ return MatchKind.none;
+ }
+ case TypeScript.NodeType.ClassDeclaration:
+ case TypeScript.NodeType.ModuleDeclaration:
+ case TypeScript.NodeType.InterfaceDeclaration:
+ return MatchKind.exact;
+ default:
+ return null;
+ }
+ };
+ return this.getASTItems(script.locationInfo.unitIndex, script, match, findMinChar, findLimChar);
+ };
+ LanguageService.prototype.logAST = function (fileName) {
+ this.refresh();
+ var script = this.compilerState.getScriptAST(fileName);
+ new TypeScript.AstLogger(this.logger).logScript(script);
+ };
+ LanguageService.prototype.logSyntaxAST = function (fileName) {
+ this.minimalRefresh();
+ var syntaxAST = this._getScriptSyntaxAST(fileName);
+ new TypeScript.AstLogger(this.logger).logScript(syntaxAST.getScript());
+ };
+ LanguageService.prototype.getErrors = function (maxCount) {
+ this.compilerState.refresh(false);
+ return this.compilerState.getErrorEntries(maxCount, function (u, e) {
+ return true;
+ });
+ };
+ LanguageService.prototype.getScriptErrors = function (fileName, maxCount) {
+ this.refresh();
+ var unitIndex = this.compilerState.getUnitIndex(fileName);
+ return this.compilerState.getErrorEntries(maxCount, function (u, e) {
+ return u === unitIndex;
+ });
+ };
+ LanguageService.prototype.getEmitOutput = function (fileName) {
+ this.refresh();
+ return this.compilerState.getEmitOutput(fileName);
+ };
+ LanguageService.prototype.getTypeInfoAtPosition = function (pos, script, constructorIsValid) {
+ var result = null;
+ var callExpr = [];
+ var createTypeInfoAtPosition = function (minChar, limChar, ast, type, forceNew) {
+ var typeInfoAtPosition = {
+ spanInfo: new SpanInfo(minChar, limChar),
+ ast: ast
+ };
+ if(callExpr.length > 0) {
+ var curCallExpr = callExpr[callExpr.length - 1];
+ if(curCallExpr.target.type == type) {
+ typeInfoAtPosition.callSignature = curCallExpr.signature;
+ typeInfoAtPosition.isNew = forceNew || curCallExpr.nodeType == TypeScript.NodeType.New;
+ }
+ }
+ return typeInfoAtPosition;
+ };
+ var pre = function (cur, parent) {
+ if(TypeScript.isValidAstNode(cur)) {
+ if(pos >= cur.minChar && pos < cur.limChar) {
+ switch(cur.nodeType) {
+ case TypeScript.NodeType.Call:
+ case TypeScript.NodeType.New:
+ var curCallExpr = cur;
+ if(pos >= curCallExpr.target.minChar && pos < curCallExpr.target.limChar) {
+ callExpr.push(curCallExpr);
+ }
+ break;
+ case TypeScript.NodeType.Dot:
+ if(result == null) {
+ result = createTypeInfoAtPosition(cur.minChar, cur.limChar, cur, cur.type);
+ }
+ break;
+ case TypeScript.NodeType.Name:
+ result = createTypeInfoAtPosition(result == null ? cur.minChar : result.spanInfo.minChar, cur.limChar, cur, (cur).sym ? (cur).sym.getType() : cur.type);
+ result.symbol = (cur).sym;
+ break;
+ case TypeScript.NodeType.FuncDecl:
+ var funcDecl = cur;
+ if(constructorIsValid && funcDecl.constructorSpan && pos >= funcDecl.constructorSpan.minChar && pos < funcDecl.constructorSpan.limChar) {
+ result = {
+ spanInfo: new SpanInfo(funcDecl.constructorSpan.minChar, funcDecl.constructorSpan.limChar),
+ ast: cur,
+ callSignature: funcDecl.signature,
+ isNew: true
+ };
+ }
+ break;
+ case TypeScript.NodeType.Super:
+ result = createTypeInfoAtPosition(cur.minChar, cur.limChar, cur, cur.type, true);
+ result.symbol = cur.type.symbol;
+ break;
+ case TypeScript.NodeType.QString:
+ case TypeScript.NodeType.This:
+ result = createTypeInfoAtPosition(cur.minChar, cur.limChar, cur, cur.type);
+ break;
+ }
+ } else if(result && callExpr.length > 0) {
+ var curCallExpr = callExpr[callExpr.length - 1];
+ if(curCallExpr.target.minChar >= cur.minChar && curCallExpr.target.minChar < cur.limChar) {
+ result.callSignature = null;
+ }
+ }
+ }
+ return cur;
+ };
+ var post = function (cur, parent) {
+ var callExprLength = callExpr.length;
+ if(callExprLength > 0 && callExpr[callExprLength - 1] == parent) {
+ callExpr.pop();
+ }
+ return cur;
+ };
+ TypeScript.getAstWalkerFactory().walk(script, pre, post);
+ return result;
+ };
+ LanguageService.prototype.getReferencesToField = function (context, symbolSet, match) {
+ var fieldMatch = function (unitIndex, parent, cur) {
+ if(cur.nodeType == TypeScript.NodeType.Name) {
+ match(unitIndex, parent, cur);
+ }
+ };
+ return this.getReferencesToSymbolSet(context, symbolSet, fieldMatch);
+ };
+ LanguageService.prototype.getReferencesToType = function (context, symbolSet, match) {
+ var typeMatch = function (unitIndex, parent, cur) {
+ if(cur.nodeType == TypeScript.NodeType.Name) {
+ match(unitIndex, parent, cur);
+ }
+ };
+ return this.getReferencesToSymbolSet(context, symbolSet, typeMatch);
+ };
+ LanguageService.prototype.getReferencesToParameter = function (context, symbolSet, match) {
+ var parameterMatch = function (unitIndex, parent, cur) {
+ if(cur.nodeType == TypeScript.NodeType.Name) {
+ match(unitIndex, parent, cur);
+ }
+ };
+ return this.getReferencesToSymbolSet(context, symbolSet, parameterMatch);
+ };
+ LanguageService.prototype.getReferencesToVariable = function (context, symbolSet, match) {
+ var variableMatch = function (unitIndex, parent, cur) {
+ if(cur.nodeType == TypeScript.NodeType.Name) {
+ match(unitIndex, parent, cur);
+ }
+ };
+ return this.getReferencesToSymbolSet(context, symbolSet, variableMatch);
+ };
+ LanguageService.prototype.getReferencesToSymbolSet = function (context, symbolSet, match) {
+ var _this = this;
+ var processScript = function (unitIndex) {
+ var pre = function (cur, parent) {
+ if(TypeScript.isValidAstNode(cur)) {
+ var sym = (cur).sym;
+ if(sym != null && symbolSet.contains(sym)) {
+ match(unitIndex, parent, cur);
+ }
+ }
+ return cur;
+ };
+ TypeScript.getAstWalkerFactory().walk(_this.compilerState.getScript(unitIndex), pre);
+ };
+ for(var i = 0, len = context.scope.length; i < len; i++) {
+ processScript(context.scope[i]);
+ }
+ };
+ LanguageService.prototype.getDeclNodeElementKindModifiers = function (ast) {
+ var addModifier = function (result, testValue, value) {
+ if(!testValue) {
+ return result;
+ }
+ if(result === ScriptElementKindModifier.none) {
+ return value;
+ } else {
+ return result + "," + value;
+ }
+ };
+ var typeDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isExported(), ScriptElementKindModifier.exportedModifier);
+ result = addModifier(result, decl.isAmbient(), ScriptElementKindModifier.ambientModifier);
+ return result;
+ };
+ var classDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isExported(), ScriptElementKindModifier.exportedModifier);
+ result = addModifier(result, decl.isAmbient(), ScriptElementKindModifier.ambientModifier);
+ return result;
+ };
+ var moduleDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isExported(), ScriptElementKindModifier.exportedModifier);
+ result = addModifier(result, decl.isAmbient(), ScriptElementKindModifier.ambientModifier);
+ return result;
+ };
+ var varDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isExported(), ScriptElementKindModifier.exportedModifier);
+ result = addModifier(result, decl.isAmbient(), ScriptElementKindModifier.ambientModifier);
+ result = addModifier(result, decl.isPublic(), ScriptElementKindModifier.publicMemberModifier);
+ result = addModifier(result, decl.isPrivate(), ScriptElementKindModifier.privateMemberModifier);
+ result = addModifier(result, decl.isStatic(), ScriptElementKindModifier.staticModifier);
+ return result;
+ };
+ var argDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isPublic(), ScriptElementKindModifier.publicMemberModifier);
+ result = addModifier(result, decl.isPrivate(), ScriptElementKindModifier.privateMemberModifier);
+ return result;
+ };
+ var funcDeclToKindModifiers = function (decl) {
+ var result = ScriptElementKindModifier.none;
+ result = addModifier(result, decl.isExported(), ScriptElementKindModifier.exportedModifier);
+ result = addModifier(result, decl.isAmbient(), ScriptElementKindModifier.ambientModifier);
+ result = addModifier(result, decl.isPublic(), ScriptElementKindModifier.publicMemberModifier);
+ result = addModifier(result, decl.isPrivate(), ScriptElementKindModifier.privateMemberModifier);
+ result = addModifier(result, decl.isStatic(), ScriptElementKindModifier.staticModifier);
+ return result;
+ };
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.InterfaceDeclaration:
+ var typeDecl = ast;
+ return typeDeclToKindModifiers(typeDecl);
+ case TypeScript.NodeType.ClassDeclaration:
+ var classDecl = ast;
+ return classDeclToKindModifiers(classDecl);
+ case TypeScript.NodeType.ModuleDeclaration:
+ var moduleDecl = ast;
+ return moduleDeclToKindModifiers(moduleDecl);
+ case TypeScript.NodeType.VarDecl:
+ var varDecl = ast;
+ return varDeclToKindModifiers(varDecl);
+ case TypeScript.NodeType.ArgDecl:
+ var argDecl = ast;
+ return argDeclToKindModifiers(argDecl);
+ case TypeScript.NodeType.FuncDecl:
+ var funcDecl = ast;
+ return funcDeclToKindModifiers(funcDecl);
+ default:
+ if(this.logger.warning()) {
+ this.logger.log("Warning: unrecognized AST node type: " + (TypeScript.NodeType)._map[ast.nodeType]);
+ }
+ return ScriptElementKindModifier.none;
+ }
+ };
+ LanguageService.prototype.getASTItems = function (unitIndex, ast, match, findMinChar, findLimChar) {
+ var _this = this;
+ if(findMinChar == null) {
+ findMinChar = function (parent, ast) {
+ return ast.minChar;
+ };
+ }
+ if(findLimChar == null) {
+ findLimChar = function (parent, ast) {
+ return ast.limChar;
+ };
+ }
+ var context = new NavigateToContext();
+ context.unitIndex = unitIndex;
+ var addItem = function (parent, ast, name, kind) {
+ if(!TypeScript.isValidAstNode(ast)) {
+ return null;
+ }
+ var matchKind = match(parent, ast, name);
+ var minChar = findMinChar(parent, ast);
+ var limChar = findLimChar(parent, ast);
+ if(matchKind != null && minChar >= 0 && limChar >= 0 && limChar >= minChar) {
+ var item = new NavigateToItem();
+ item.name = name;
+ item.matchKind = matchKind;
+ item.kind = kind;
+ item.kindModifiers = _this.getDeclNodeElementKindModifiers(ast);
+ item.unitIndex = _this.compilerState.mapToHostUnitIndex(context.unitIndex);
+ item.minChar = minChar;
+ item.limChar = limChar;
+ item.containerName = (TypeScript.lastOf(context.containerSymbols) === null ? "" : TypeScript.lastOf(context.containerSymbols).fullName());
+ item.containerKind = TypeScript.lastOf(context.containerKinds) === null ? "" : TypeScript.lastOf(context.containerKinds);
+ return item;
+ }
+ return null;
+ };
+ var getLimChar = function (ast) {
+ return (ast == null ? -1 : ast.limChar);
+ };
+ var pre = function (ast, parent, walker) {
+ context.path.push(ast);
+ if(!TypeScript.isValidAstNode(ast)) {
+ return ast;
+ }
+ var item = null;
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.InterfaceDeclaration:
+ {
+ var typeDecl = ast;
+ item = addItem(parent, typeDecl, typeDecl.name.actualText, ScriptElementKind.interfaceElement);
+ context.containerASTs.push(ast);
+ context.containerSymbols.push(typeDecl.type.symbol);
+ context.containerKinds.push("interface");
+ }
+ break;
+ case TypeScript.NodeType.ClassDeclaration:
+ {
+ var classDecl = ast;
+ item = addItem(parent, classDecl, classDecl.name.actualText, ScriptElementKind.classElement);
+ context.containerASTs.push(ast);
+ context.containerSymbols.push(classDecl.type.symbol);
+ context.containerKinds.push("class");
+ }
+ break;
+ case TypeScript.NodeType.ModuleDeclaration:
+ {
+ var moduleDecl = ast;
+ var isEnum = moduleDecl.isEnum();
+ var kind = isEnum ? ScriptElementKind.enumElement : ScriptElementKind.moduleElement;
+ item = addItem(parent, moduleDecl, moduleDecl.name.actualText, kind);
+ context.containerASTs.push(ast);
+ context.containerSymbols.push(moduleDecl.mod.symbol);
+ context.containerKinds.push(kind);
+ }
+ break;
+ case TypeScript.NodeType.VarDecl:
+ {
+ var varDecl = ast;
+ if(varDecl.id !== null) {
+ if(varDecl.isProperty()) {
+ item = addItem(parent, varDecl, varDecl.id.actualText, ScriptElementKind.memberVariableElement);
+ } else if(context.path.isChildOfScript() || context.path.isChildOfModule()) {
+ item = addItem(parent, varDecl, varDecl.id.actualText, ScriptElementKind.variableElement);
+ }
+ }
+ }
+ walker.options.goChildren = false;
+ break;
+ case TypeScript.NodeType.ArgDecl:
+ {
+ var argDecl = ast;
+ if(argDecl.id !== null) {
+ if(context.path.isArgumentOfClassConstructor()) {
+ if(argDecl.isProperty()) {
+ item = addItem(parent, argDecl, argDecl.id.actualText, ScriptElementKind.memberVariableElement);
+ }
+ }
+ }
+ }
+ walker.options.goChildren = false;
+ break;
+ case TypeScript.NodeType.FuncDecl:
+ {
+ var funcDecl = ast;
+ var kind = null;
+ var name = (funcDecl.name !== null ? funcDecl.name.actualText : null);
+ if(funcDecl.isGetAccessor()) {
+ kind = ScriptElementKind.memberGetAccessorElement;
+ } else if(funcDecl.isSetAccessor()) {
+ kind = ScriptElementKind.memberSetAccessorElement;
+ } else if(funcDecl.isCallMember()) {
+ kind = ScriptElementKind.callSignatureElement;
+ name = "()";
+ } else if(funcDecl.isIndexerMember()) {
+ kind = ScriptElementKind.indexSignatureElement;
+ name = "[]";
+ } else if(funcDecl.isConstructMember()) {
+ kind = ScriptElementKind.constructSignatureElement;
+ name = "new()";
+ } else if(funcDecl.isConstructor) {
+ kind = ScriptElementKind.constructorImplementationElement;
+ name = "constructor";
+ } else if(funcDecl.isMethod()) {
+ kind = ScriptElementKind.memberFunctionElement;
+ } else if(context.path.isChildOfScript() || context.path.isChildOfModule()) {
+ kind = ScriptElementKind.functionElement;
+ }
+ if(kind !== null && name !== null) {
+ item = addItem(parent, funcDecl, name, kind);
+ }
+ }
+ break;
+ case TypeScript.NodeType.ObjectLit:
+ walker.options.goChildren = false;
+ break;
+ }
+ if(item !== null) {
+ context.result.push(item);
+ }
+ return ast;
+ };
+ var post = function (ast, parent) {
+ context.path.pop();
+ if(ast === TypeScript.lastOf(context.containerASTs)) {
+ context.containerASTs.pop();
+ context.containerSymbols.pop();
+ context.containerKinds.pop();
+ }
+ return ast;
+ };
+ TypeScript.getAstWalkerFactory().walk(ast, pre, post);
+ return context.result;
+ };
+ LanguageService.prototype.getAstPathToPosition = function (script, pos, options) {
+ if (typeof options === "undefined") { options = TypeScript.GetAstPathOptions.Default; }
+ if(this.logger.information()) {
+ this.logger.log("getAstPathToPosition(" + script + ", " + pos + ")");
+ }
+ var path = TypeScript.getAstPathToPosition(script, pos, options);
+ if(this.logger.information()) {
+ if(path.count() == 0) {
+ this.logger.log("getAstPathToPosition: no ast found at position");
+ } else {
+ new TypeScript.AstLogger(this.logger).logNode(script, path.ast(), 0);
+ }
+ }
+ return path;
+ };
+ LanguageService.prototype.getIdentifierPathToPosition = function (script, pos) {
+ this.logger.log("getIdentifierPathToPosition(" + script + ", " + pos + ")");
+ var path = this.getAstPathToPosition(script, pos, TypeScript.GetAstPathOptions.EdgeInclusive);
+ if(path.count() == 0) {
+ return null;
+ }
+ if(path.nodeType() !== TypeScript.NodeType.Name) {
+ return null;
+ }
+ return path;
+ };
+ LanguageService.prototype.getSymbolAtPosition = function (script, pos) {
+ this.logger.log("getSymbolAtPosition(" + script + ", " + pos + ")");
+ var path = this.getAstPathToPosition(script, pos);
+ if(path.count() == 0) {
+ return null;
+ }
+ var finalAST = path.ast();
+ if(finalAST == null) {
+ return null;
+ }
+ if(finalAST.sym) {
+ return finalAST.sym;
+ }
+ if(finalAST.nodeType == TypeScript.NodeType.Dot && finalAST.operand2.sym) {
+ return finalAST.operand2.sym;
+ }
+ if(finalAST.signature && finalAST.signature.returnType && finalAST.signature.returnType.type && finalAST.signature.returnType.type.symbol) {
+ return finalAST.signature.returnType.type.symbol;
+ }
+ if(finalAST.type && finalAST.type.symbol) {
+ return finalAST.type.symbol;
+ }
+ return null;
+ };
+ LanguageService.prototype.logFormatCodeOptions = function (options) {
+ if(this.logger.information()) {
+ this.logger.log("options.InsertSpaceAfterCommaDelimiter=" + options.InsertSpaceAfterCommaDelimiter);
+ this.logger.log("options.InsertSpaceAfterSemicolonInForStatements=" + options.InsertSpaceAfterSemicolonInForStatements);
+ this.logger.log("options.InsertSpaceBeforeAndAfterBinaryOperators=" + options.InsertSpaceBeforeAndAfterBinaryOperators);
+ this.logger.log("options.InsertSpaceAfterKeywordsInControlFlowStatements=" + options.InsertSpaceAfterKeywordsInControlFlowStatements);
+ this.logger.log("options.InsertSpaceAfterFunctionKeywordForAnonymousFunctions=" + options.InsertSpaceAfterFunctionKeywordForAnonymousFunctions);
+ this.logger.log("options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis=" + options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis);
+ this.logger.log("options.PlaceOpenBraceOnNewLineForFunctions=" + options.PlaceOpenBraceOnNewLineForFunctions);
+ this.logger.log("options.PlaceOpenBraceOnNewLineForControlBlocks=" + options.PlaceOpenBraceOnNewLineForControlBlocks);
+ }
+ };
+ LanguageService.prototype.logEditResults = function (syntaxAST, result) {
+ var _this = this;
+ if(this.logger.information()) {
+ var logSourceText = function (text) {
+ var textLines = text.replace(/^\s+|\s+$/g, "").replace(/\r\n?/g, "\n").split(/\n/);
+ for(var i = 0; i < textLines.length; i++) {
+ var textLine = textLines[i];
+ var msg = "line #" + i + "(length=" + textLine.length + "): \"" + textLine + "\"";
+ _this.logger.log(msg);
+ }
+ };
+ var sourceText = syntaxAST.getSourceText();
+ logSourceText(sourceText.getText(0, sourceText.getLength()));
+ for(var i = 0; i < result.length; i++) {
+ var edit = result[i];
+ var oldSourceText = sourceText.getText(edit.minChar, edit.limChar);
+ var text = "edit #" + i + ": minChar=" + edit.minChar + ", " + "limChar=" + edit.limChar + ", " + "oldText=\"" + TypeScript.stringToLiteral(oldSourceText, 30) + "\", " + "textLength=" + edit.text.length + ", " + "text=\"" + TypeScript.stringToLiteral(edit.text, 30) + "\"";
+ this.logger.log(text);
+ }
+ }
+ };
+ return LanguageService;
+ })();
+ Services.LanguageService = LanguageService;
+})(Services || (Services = {}));
+var debugObjectHost = (this);
+var Services;
+(function (Services) {
+ var CoreServices = (function () {
+ function CoreServices(host) {
+ this.host = host;
+ }
+ CoreServices.prototype.getPreProcessedFileInfo = function (scritpId, sourceText) {
+ var settings = new TypeScript.CompilationSettings();
+ settings.codeGenTarget = TypeScript.CodeGenTarget.ES5;
+ var result = TypeScript.preProcessFile(sourceText, settings);
+ return result;
+ };
+ CoreServices.prototype.getDefaultCompilationSettings = function () {
+ var settings = new TypeScript.CompilationSettings();
+ settings.codeGenTarget = TypeScript.CodeGenTarget.ES5;
+ return settings;
+ };
+ CoreServices.prototype.dumpMemory = function () {
+ if(!debugObjectHost || !debugObjectHost.Debug || !debugObjectHost.Debug.dumpHeap) {
+ throw new Error("This version of the Javascript runtime doesn't support the 'Debug.dumpHeap()' function.");
+ }
+ var objects = debugObjectHost.Debug.dumpHeap(2);
+ var totalSize = 0;
+ for(var i = 0; i < objects.length; i++) {
+ totalSize += objects[i].size;
+ }
+ return "There are " + objects.length + " object(s) accessible from 'global', for a total of " + totalSize + " byte(s).";
+ };
+ CoreServices.prototype.getMemoryInfo = function () {
+ if(!debugObjectHost || !debugObjectHost.Debug || !debugObjectHost.Debug.getMemoryInfo) {
+ throw new Error("This version of the Javascript runtime doesn't support the 'Debug.getMemoryInfo()' function.");
+ }
+ return debugObjectHost.Debug.getMemoryInfo();
+ };
+ CoreServices.prototype.collectGarbage = function () {
+ if(!debugObjectHost || !debugObjectHost.CollectGarbage) {
+ throw new Error("This version of the Javascript runtime doesn't support the 'CollectGarbage()' function.");
+ }
+ debugObjectHost.CollectGarbage();
+ };
+ return CoreServices;
+ })();
+ Services.CoreServices = CoreServices;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var ScriptMap = (function () {
+ function ScriptMap() {
+ this.map = new TypeScript.StringHashTable();
+ }
+ ScriptMap.prototype.setEntry = function (id, isResident, version) {
+ var entry = this.map.lookup(id);
+ if(entry == null) {
+ entry = new ScriptMapEntry(isResident, version);
+ this.map.add(id, entry);
+ } else {
+ entry.isResident = isResident;
+ entry.version = version;
+ }
+ };
+ ScriptMap.prototype.getEntry = function (id) {
+ return this.map.lookup(id);
+ };
+ return ScriptMap;
+ })();
+ Services.ScriptMap = ScriptMap;
+ var ScriptMapEntry = (function () {
+ function ScriptMapEntry(isResident, version) {
+ this.isResident = isResident;
+ this.version = version;
+ }
+ return ScriptMapEntry;
+ })();
+ Services.ScriptMapEntry = ScriptMapEntry;
+ var HostCacheEntry = (function () {
+ function HostCacheEntry(host, hostUnitIndex, id, version, isResident) {
+ this.host = host;
+ this.hostUnitIndex = hostUnitIndex;
+ this.id = id;
+ this.version = version;
+ this.isResident = isResident;
+ this._cachedSourceText = null;
+ this._sourceText = null;
+ }
+ HostCacheEntry.prototype.getSourceText = function (cached) {
+ if(cached) {
+ if(this._cachedSourceText === null) {
+ this._cachedSourceText = new Services.CachedSourceTextAdapter(this.host, this.hostUnitIndex);
+ }
+ return this._cachedSourceText;
+ } else {
+ if(this._sourceText === null) {
+ this._sourceText = new Services.SourceTextAdapter(this.host, this.hostUnitIndex);
+ }
+ return this._sourceText;
+ }
+ };
+ return HostCacheEntry;
+ })();
+ Services.HostCacheEntry = HostCacheEntry;
+ var HostCache = (function () {
+ function HostCache(host) {
+ this.host = host;
+ this.map = new TypeScript.StringHashTable();
+ this.array = [];
+ this.init();
+ }
+ HostCache.prototype.init = function () {
+ for(var i = 0, len = this.host.getScriptCount(); i < len; i++) {
+ var scriptId = this.host.getScriptId(i);
+ this.map.add(scriptId, i);
+ this.array[i] = new HostCacheEntry(this.host, i, scriptId, this.host.getScriptVersion(i), this.host.getScriptIsResident(i));
+ }
+ };
+ HostCache.prototype.count = function () {
+ return this.map.count();
+ };
+ HostCache.prototype.getUnitIndex = function (scriptId) {
+ var result = this.map.lookup(scriptId);
+ if(result == null) {
+ return -1;
+ }
+ return result;
+ };
+ HostCache.prototype.getVersion = function (scriptIndex) {
+ return this.array[scriptIndex].version;
+ };
+ HostCache.prototype.getIsResident = function (scriptIndex) {
+ return this.array[scriptIndex].isResident;
+ };
+ HostCache.prototype.getScriptId = function (scriptIndex) {
+ return this.array[scriptIndex].id;
+ };
+ HostCache.prototype.getSourceText = function (scriptIndex, cached) {
+ if (typeof cached === "undefined") { cached = false; }
+ return this.array[scriptIndex].getSourceText(cached);
+ };
+ return HostCache;
+ })();
+ Services.HostCache = HostCache;
+ var CompilerCache = (function () {
+ function CompilerCache(compiler) {
+ this.compiler = compiler;
+ this.map = new TypeScript.StringHashTable();
+ this.init();
+ }
+ CompilerCache.prototype.init = function () {
+ for(var i = 0, len = this.compiler.units.length; i < len; i++) {
+ this.map.add(this.compiler.units[i].filename, i);
+ }
+ };
+ CompilerCache.prototype.getUnitIndex = function (scriptId) {
+ var result = this.map.lookup(scriptId);
+ if(result == null) {
+ return -1;
+ }
+ return result;
+ };
+ return CompilerCache;
+ })();
+ Services.CompilerCache = CompilerCache;
+ var UnitErrors = (function () {
+ function UnitErrors() {
+ this.parseErrors = [];
+ this.typeCheckErrors = [];
+ }
+ return UnitErrors;
+ })();
+ Services.UnitErrors = UnitErrors;
+ var CompilerErrorCollector = (function () {
+ function CompilerErrorCollector(logger) {
+ this.logger = logger;
+ this.parseMode = false;
+ this.fileMap = [];
+ }
+ CompilerErrorCollector.prototype.startParsing = function (unitIndex) {
+ this.parseMode = true;
+ var errors = this.fileMap[unitIndex];
+ if(errors !== undefined) {
+ errors.parseErrors.length = 0;
+ }
+ };
+ CompilerErrorCollector.prototype.startTypeChecking = function () {
+ this.parseMode = false;
+ for(var i = 0; i < this.fileMap.length; i++) {
+ var errors = this.fileMap[i];
+ if(errors !== undefined) {
+ errors.typeCheckErrors.length = 0;
+ }
+ }
+ };
+ CompilerErrorCollector.prototype.reportError = function (pos, len, message, unitIndex) {
+ var entry = new TypeScript.ErrorEntry(unitIndex, pos, pos + len, message);
+ var unitErrors = this.fileMap[unitIndex];
+ if(unitErrors == undefined) {
+ unitErrors = new UnitErrors();
+ this.fileMap[unitIndex] = unitErrors;
+ }
+ if(this.parseMode) {
+ unitErrors.parseErrors.push(entry);
+ } else {
+ unitErrors.typeCheckErrors.push(entry);
+ }
+ };
+ return CompilerErrorCollector;
+ })();
+ Services.CompilerErrorCollector = CompilerErrorCollector;
+ var TextWriter = (function () {
+ function TextWriter(name, useUTF8encoding) {
+ this.name = name;
+ this.useUTF8encoding = useUTF8encoding;
+ this.text = "";
+ }
+ TextWriter.prototype.Write = function (s) {
+ this.text += s;
+ };
+ TextWriter.prototype.WriteLine = function (s) {
+ this.text += s + '\n';
+ };
+ TextWriter.prototype.Close = function () {
+ };
+ return TextWriter;
+ })();
+ var CompilerState = (function () {
+ function CompilerState(host) {
+ this.host = host;
+ this.logger = this.host;
+ this.compiler = null;
+ this.errorCollector = null;
+ this.unitIndexMap = [];
+ this.scriptMap = null;
+ this.hostCache = null;
+ this.compilerCache = null;
+ this.symbolTree = null;
+ this.compilationSettings = null;
+ }
+ CompilerState.prototype.getCompilationSettings = function () {
+ return this.compilationSettings;
+ };
+ CompilerState.prototype.setUnitMapping = function (unitIndex, hostUnitIndex) {
+ this.scriptMap.setEntry(this.hostCache.getScriptId(hostUnitIndex), this.hostCache.getIsResident(hostUnitIndex), this.hostCache.getVersion(hostUnitIndex));
+ this.setUnitIndexMapping(unitIndex, hostUnitIndex);
+ };
+ CompilerState.prototype.setUnitIndexMapping = function (unitIndex, hostUnitIndex) {
+ this.unitIndexMap[unitIndex] = hostUnitIndex;
+ };
+ CompilerState.prototype.onTypeCheckStarting = function () {
+ this.errorCollector.startTypeChecking();
+ this.symbolTree = new Services.SymbolTree(this);
+ };
+ CompilerState.prototype.getSymbolTree = function () {
+ return this.symbolTree;
+ };
+ CompilerState.prototype.mapToHostUnitIndex = function (unitIndex) {
+ return this.unitIndexMap[unitIndex];
+ };
+ CompilerState.prototype.anyType = function () {
+ return this.compiler.typeFlow.anyType;
+ };
+ CompilerState.prototype.getScriptCount = function () {
+ return this.compiler.scripts.members.length;
+ };
+ CompilerState.prototype.getScript = function (index) {
+ return this.compiler.scripts.members[index];
+ };
+ CompilerState.prototype.getScripts = function () {
+ return this.compiler.scripts.members;
+ };
+ CompilerState.prototype.getUnitIndex = function (fileName) {
+ return this.compilerCache.getUnitIndex(fileName);
+ };
+ CompilerState.prototype.getScriptVersion = function (fileName) {
+ return this.hostCache.getVersion(this.hostCache.getUnitIndex(fileName));
+ };
+ CompilerState.prototype.addCompilerUnit = function (compiler, hostUnitIndex) {
+ var newUnitIndex = compiler.units.length;
+ this.errorCollector.startParsing(newUnitIndex);
+ this.setUnitMapping(newUnitIndex, hostUnitIndex);
+ var newScript = compiler.addSourceUnit(this.hostCache.getSourceText(hostUnitIndex), this.hostCache.getScriptId(hostUnitIndex), this.hostCache.getIsResident(hostUnitIndex));
+ };
+ CompilerState.prototype.updateCompilerUnit = function (compiler, hostUnitIndex, unitIndex) {
+ var scriptId = this.hostCache.getScriptId(hostUnitIndex);
+ this.setUnitIndexMapping(unitIndex, hostUnitIndex);
+ var previousEntry = this.scriptMap.getEntry(scriptId);
+ var isResident = this.hostCache.getIsResident(hostUnitIndex);
+ if(isResident) {
+ return TypeScript.UpdateUnitResult.noEdits(unitIndex);
+ }
+ var version = this.hostCache.getVersion(hostUnitIndex);
+ if(previousEntry.version === version) {
+ return TypeScript.UpdateUnitResult.noEdits(unitIndex);
+ }
+ var result = this.attemptIncrementalUpdateUnit(scriptId);
+ if(result != null) {
+ return result;
+ }
+ var sourceText = this.hostCache.getSourceText(hostUnitIndex);
+ this.setUnitMapping(unitIndex, hostUnitIndex);
+ return compiler.partialUpdateUnit(sourceText, scriptId, true);
+ };
+ CompilerState.prototype.attemptIncrementalUpdateUnit = function (scriptId) {
+ var previousScript = this.getScriptAST(scriptId);
+ var newSourceText = this.getSourceText(previousScript, false);
+ var editRange = this.getScriptEditRange(previousScript);
+ var result = new TypeScript.IncrementalParser(this.logger).attemptIncrementalUpdateUnit(previousScript, scriptId, newSourceText, editRange);
+ if(result == null) {
+ return null;
+ }
+ if(result.kind === TypeScript.UpdateUnitKind.EditsInsideSingleScope) {
+ if(result.scope1.nodeType != TypeScript.NodeType.FuncDecl) {
+ this.logger.log(" Bailing out because containing scope is not a function");
+ return null;
+ }
+ }
+ if(true) {
+ this.logger.log(" Bailing out because incremental typecheck is not implemented yet");
+ return null;
+ } else {
+ return result;
+ }
+ };
+ CompilerState.prototype.getHostCompilationSettings = function () {
+ var settings = this.host.getCompilationSettings();
+ if(settings !== null) {
+ return settings;
+ }
+ settings = new TypeScript.CompilationSettings();
+ settings.codeGenTarget = TypeScript.CodeGenTarget.ES5;
+ return settings;
+ };
+ CompilerState.prototype.createCompiler = function () {
+ var _this = this;
+ var outerr = {
+ Write: function (s) {
+ },
+ WriteLine: function (s) {
+ },
+ Close: function () {
+ }
+ };
+ this.logger.log("Initializing compiler");
+ this.compilationSettings = new TypeScript.CompilationSettings();
+ Services.copyDataObject(this.compilationSettings, this.getHostCompilationSettings());
+ this.compiler = new TypeScript.TypeScriptCompiler(outerr, this.logger, this.compilationSettings);
+ this.scriptMap = new ScriptMap();
+ this.unitIndexMap = [];
+ this.errorCollector = new CompilerErrorCollector(this.logger);
+ this.compiler.setErrorCallback(function (a, b, c, d) {
+ _this.errorCollector.reportError(a, b, c, d);
+ });
+ this.compiler.parser.errorRecovery = true;
+ for(var i = 0, length = this.host.getScriptCount(); i < length; i++) {
+ this.addCompilerUnit(this.compiler, i);
+ }
+ this.compilerCache = new CompilerCache(this.compiler);
+ this.onTypeCheckStarting();
+ this.compiler.typeCheck();
+ };
+ CompilerState.prototype.minimalRefresh = function () {
+ this.hostCache = new HostCache(this.host);
+ };
+ CompilerState.prototype.refresh = function (throwOnError) {
+ if (typeof throwOnError === "undefined") { throwOnError = true; }
+ try {
+ this.hostCache = new HostCache(this.host);
+ if(!this.fullRefresh()) {
+ this.partialRefresh();
+ }
+ if(this.logger.information()) {
+ for(var i = 0; i < this.compiler.units.length; i++) {
+ this.logger.log("compiler unit[" + i + "].filename='" + this.compiler.units[i].filename + "'");
+ }
+ for(var i = 0; i < this.hostCache.count(); i++) {
+ this.logger.log("host script[" + i + "].filename='" + this.hostCache.getScriptId(i) + "', version=" + this.hostCache.getVersion(i));
+ }
+ for(var i = 0; i < this.unitIndexMap.length; i++) {
+ this.logger.log("unitIndexMap[" + i + "] = " + this.unitIndexMap[i]);
+ }
+ }
+ } catch (err) {
+ var lastUnitIndex = 0;
+ if(this.compiler != null) {
+ lastUnitIndex = this.compiler.units.length - 1;
+ }
+ this.compiler = null;
+ this.logger.log("WARNING: PERF: Internal error during \"Refresh\":");
+ Services.logInternalError(this.logger, err);
+ this.logger.log("WARNING: PERF: Compiler state is lost and will be re-initiliazed during next call.");
+ this.errorCollector.reportError(0, 1, "Internal error: " + err.message, lastUnitIndex);
+ this.errorCollector.reportError(0, 1, "Internal error: IntelliSense features are disabled. Try making edits to source files to restore a valid compilation state.", lastUnitIndex);
+ if(throwOnError) {
+ throw err;
+ }
+ }
+ };
+ CompilerState.prototype.fullRefresh = function () {
+ if(this.compiler == null) {
+ this.logger.log("Creating new compiler instance because there is no currently active instance");
+ this.createCompiler();
+ return true;
+ }
+ if(!Services.compareDataObjects(this.compilationSettings, this.getHostCompilationSettings())) {
+ this.logger.log("Creating new compiler instance because compilation settings have changed.");
+ this.createCompiler();
+ return true;
+ }
+ for(var unitIndex = 0, len = this.compiler.units.length; unitIndex < len; unitIndex++) {
+ var fileName = this.compiler.units[unitIndex].filename;
+ var hostUnitIndex = this.hostCache.getUnitIndex(fileName);
+ if(hostUnitIndex < 0) {
+ this.logger.log("Creating new compiler instance because of unit is not part of program anymore: " + unitIndex + "-" + fileName);
+ this.createCompiler();
+ return true;
+ }
+ }
+ for(var unitIndex = 0, len = this.compiler.units.length; unitIndex < len; unitIndex++) {
+ var fileName = this.compiler.units[unitIndex].filename;
+ var isResident = (this.compiler.scripts.members[unitIndex]).isResident;
+ var hostUnitIndex = this.hostCache.getUnitIndex(fileName);
+ if(this.hostCache.getIsResident(hostUnitIndex) != isResident) {
+ this.logger.log("Creating new compiler instance because of unit 'isResident' status has changed: " + unitIndex + "-" + fileName);
+ this.createCompiler();
+ return true;
+ }
+ }
+ return false;
+ };
+ CompilerState.prototype.partialRefresh = function () {
+ this.logger.log("Updating files...");
+ this.compilerCache = new CompilerCache(this.compiler);
+ var updateResults = [];
+ function getSingleFunctionEdit(updateResults) {
+ var result = null;
+ for(var i = 0, len = updateResults.length; i < len; i++) {
+ var entry = updateResults[i];
+ if(entry.kind == TypeScript.UpdateUnitKind.EditsInsideSingleScope) {
+ if(result === null) {
+ result = entry;
+ } else {
+ result = null;
+ break;
+ }
+ } else if(entry.kind == TypeScript.UpdateUnitKind.Unknown) {
+ result = null;
+ break;
+ }
+ }
+ return result;
+ }
+ var fileAdded = false;
+ for(var hostUnitIndex = 0, len = this.host.getScriptCount(); hostUnitIndex < len; hostUnitIndex++) {
+ var fileName = this.hostCache.getScriptId(hostUnitIndex);
+ var unitIndex = this.compilerCache.getUnitIndex(fileName);
+ if(unitIndex >= 0) {
+ var updateResult = this.updateCompilerUnit(this.compiler, hostUnitIndex, unitIndex);
+ updateResults.push(updateResult);
+ } else {
+ this.addCompilerUnit(this.compiler, hostUnitIndex);
+ fileAdded = true;
+ }
+ }
+ var incrementalTypeCheckSuccessful = false;
+ var singleEdit = getSingleFunctionEdit(updateResults);
+ if(fileAdded === false && singleEdit !== null) {
+ this.logger.log("Attempting incremental type check because there was a single edit to the function \"" + (singleEdit.scope1).name.actualText + "\"");
+ incrementalTypeCheckSuccessful = this.attemptIncrementalTypeCheck(singleEdit);
+ }
+ if(!incrementalTypeCheckSuccessful) {
+ var anythingUpdated = false;
+ for(var i = 0, len = updateResults.length; i < len; i++) {
+ var entry = updateResults[i];
+ if(this.applyUpdateResult(entry)) {
+ anythingUpdated = true;
+ }
+ }
+ if(anythingUpdated) {
+ this.logger.log("Incremental type check not applicable, processing unit updates");
+ this.onTypeCheckStarting();
+ this.compiler.reTypeCheck();
+ } else {
+ this.logger.log("No updates to source files, no typecheck needed");
+ }
+ }
+ };
+ CompilerState.prototype.attemptIncrementalTypeCheck = function (updateResult) {
+ var success = this.compiler.attemptIncrementalTypeCheck(updateResult);
+ if(success) {
+ this.applyUpdateResult(updateResult);
+ }
+ return success;
+ };
+ CompilerState.prototype.applyUpdateResult = function (updateResult) {
+ switch(updateResult.kind) {
+ case TypeScript.UpdateUnitKind.NoEdits:
+ return false;
+ case TypeScript.UpdateUnitKind.Unknown:
+ case TypeScript.UpdateUnitKind.EditsInsideSingleScope:
+ this.errorCollector.startParsing(updateResult.unitIndex);
+ return this.compiler.applyUpdateResult(updateResult);
+ }
+ };
+ CompilerState.prototype.getScriptAST = function (fileName) {
+ var unitIndex = this.compilerCache.getUnitIndex(fileName);
+ if(unitIndex < 0) {
+ throw new Error("Interal error: No AST found for file \"" + fileName + "\".");
+ }
+ return this.compiler.scripts.members[unitIndex];
+ };
+ CompilerState.prototype.getLineMap = function (fileName) {
+ var unitIndex = this.compilerCache.getUnitIndex(fileName);
+ if(unitIndex < 0) {
+ throw new Error("Interal error: No AST found for file \"" + fileName + "\".");
+ }
+ return this.compiler.units[unitIndex].lineMap;
+ };
+ CompilerState.prototype.getScopeEntries = function (enclosingScopeContext, getPrettyTypeName) {
+ return new TypeScript.ScopeTraversal(this.compiler).getScopeEntries(enclosingScopeContext, getPrettyTypeName);
+ };
+ CompilerState.prototype.getErrorEntries = function (maxCount, filter) {
+ var entries = [];
+ var count = 0;
+ var addError = function (error) {
+ entries.push(error);
+ count++;
+ return (count < maxCount);
+ };
+ for(var unitIndex = 0, len = this.errorCollector.fileMap.length; unitIndex < len; unitIndex++) {
+ var errors = this.errorCollector.fileMap[unitIndex];
+ if(errors !== undefined) {
+ for(var i = 0; i < errors.parseErrors.length; i++) {
+ var error = errors.parseErrors[i];
+ if(filter(unitIndex, error)) {
+ if(!addError(error)) {
+ break;
+ }
+ }
+ }
+ for(var i = 0; i < errors.typeCheckErrors.length; i++) {
+ var error = errors.typeCheckErrors[i];
+ if(filter(unitIndex, error)) {
+ if(!addError(error)) {
+ break;
+ }
+ }
+ }
+ }
+ }
+ var result = [];
+ for(var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ var ne = new TypeScript.ErrorEntry(this.mapToHostUnitIndex(e.unitIndex), e.minChar, e.limChar, e.message);
+ result.push(ne);
+ }
+ return result;
+ };
+ CompilerState.prototype.cleanASTTypesForReTypeCheck = function (ast) {
+ this.compiler.cleanASTTypesForReTypeCheck(ast);
+ };
+ CompilerState.prototype.getScriptEditRange = function (script) {
+ var lastKnownVersion = this.scriptMap.getEntry(script.locationInfo.filename).version;
+ return this.getScriptEditRangeSinceVersion(script.locationInfo.filename, lastKnownVersion);
+ };
+ CompilerState.prototype.getScriptEditRangeSinceVersion = function (fileName, lastKnownVersion) {
+ var hostUnitIndex = this.hostCache.getUnitIndex(fileName);
+ var currentVersion = this.hostCache.getVersion(hostUnitIndex);
+ if(lastKnownVersion === currentVersion) {
+ return null;
+ }
+ return this.host.getScriptEditRangeSinceVersion(hostUnitIndex, lastKnownVersion);
+ };
+ CompilerState.prototype.getSourceText = function (script, cached) {
+ if (typeof cached === "undefined") { cached = false; }
+ return this.hostCache.getSourceText(this.hostCache.getUnitIndex(script.locationInfo.filename), cached);
+ };
+ CompilerState.prototype.getSourceText2 = function (fileName, cached) {
+ if (typeof cached === "undefined") { cached = false; }
+ return this.hostCache.getSourceText(this.hostCache.getUnitIndex(fileName), cached);
+ };
+ CompilerState.prototype.getScriptSyntaxAST = function (fileName) {
+ var sourceText = this.hostCache.getSourceText(this.hostCache.getUnitIndex(fileName), true);
+ var parser = new TypeScript.Parser();
+ parser.setErrorRecovery(null);
+ parser.errorCallback = function (a, b, c, d) {
+ };
+ var script = parser.parse(sourceText, fileName, 0);
+ return new Services.ScriptSyntaxAST(this.logger, script, sourceText);
+ };
+ CompilerState.prototype.getEmitOutput = function (fileName) {
+ var unitIndex = this.compilerCache.getUnitIndex(fileName);
+ if(unitIndex < 0) {
+ throw new Error("Interal error: No AST found for file \"" + fileName + "\".");
+ }
+ var result = [];
+ var errors = this.errorCollector.fileMap[unitIndex];
+ if(errors !== undefined && errors.parseErrors.length > 0) {
+ return result;
+ }
+ var emitterIOHost = {
+ createFile: function (fileName, useUTF8encoding) {
+ if (typeof useUTF8encoding === "undefined") { useUTF8encoding = false; }
+ var outputFile = new TextWriter(fileName, useUTF8encoding);
+ result.push(outputFile);
+ return outputFile;
+ },
+ directoryExists: function (fname) {
+ return true;
+ },
+ fileExists: function (fname) {
+ return false;
+ },
+ resolvePath: function (fname) {
+ return fname;
+ }
+ };
+ var script = this.compiler.scripts.members[unitIndex];
+ this.compiler.parseEmitOption(emitterIOHost);
+ this.compiler.emitUnit(script);
+ if(errors == undefined || errors.typeCheckErrors.length == 0) {
+ this.compiler.emitDeclarationsUnit(script);
+ }
+ return result;
+ };
+ return CompilerState;
+ })();
+ Services.CompilerState = CompilerState;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var ScriptSyntaxAST = (function () {
+ function ScriptSyntaxAST(logger, script, sourceText) {
+ this.logger = logger;
+ this.script = script;
+ this.sourceText = sourceText;
+ }
+ ScriptSyntaxAST.prototype.getLogger = function () {
+ return this.logger;
+ };
+ ScriptSyntaxAST.prototype.getScriptId = function () {
+ return this.script.locationInfo.filename;
+ };
+ ScriptSyntaxAST.prototype.getScript = function () {
+ return this.script;
+ };
+ ScriptSyntaxAST.prototype.getSourceText = function () {
+ return this.sourceText;
+ };
+ ScriptSyntaxAST.prototype.getTokenStream = function (minChar, limChar) {
+ if (typeof minChar === "undefined") { minChar = 0; }
+ if(minChar > 0) {
+ minChar = this.getTokenizationOffset(minChar);
+ }
+ if(!limChar) {
+ limChar = this.getSourceText().getLength();
+ }
+ var scannerSourceText = this.getSourceText();
+ if(minChar > 0 || limChar < scannerSourceText.getLength()) {
+ scannerSourceText = new Services.SourceTextRange(scannerSourceText, minChar, limChar);
+ }
+ var scanner = new TypeScript.Scanner();
+ scanner.resetComments();
+ scanner.setSourceText(scannerSourceText, TypeScript.LexMode.File);
+ scanner.setScanComments(true);
+ var tokenStream = new TokenStream(scanner, minChar);
+ return tokenStream;
+ };
+ ScriptSyntaxAST.prototype.getTokenizationOffset = function (position) {
+ return TypeScript.getTokenizationOffset(this.script, position);
+ };
+ ScriptSyntaxAST.prototype.getAstPathToPosition = function (pos, options) {
+ if (typeof options === "undefined") { options = TypeScript.GetAstPathOptions.Default; }
+ return TypeScript.getAstPathToPosition(this.script, pos, options);
+ };
+ return ScriptSyntaxAST;
+ })();
+ Services.ScriptSyntaxAST = ScriptSyntaxAST;
+ var TokenStream = (function () {
+ function TokenStream(scanner, offset) {
+ this.scanner = scanner;
+ this.offset = offset;
+ this.currentToken = null;
+ }
+ TokenStream.prototype.moveNext = function () {
+ this.currentToken = this.scanner.scan();
+ if(this.currentToken.tokenId === TypeScript.TokenID.EndOfFile) {
+ return false;
+ }
+ return true;
+ };
+ TokenStream.prototype.sourceTextOffset = function () {
+ return this.offset;
+ };
+ TokenStream.prototype.tokenId = function () {
+ return this.currentToken.tokenId;
+ };
+ TokenStream.prototype.tokenStartPos = function () {
+ return this.offset + this.scanner.startPos;
+ };
+ TokenStream.prototype.tokenEndPos = function () {
+ return this.offset + this.scanner.pos;
+ };
+ return TokenStream;
+ })();
+ Services.TokenStream = TokenStream;
+ var TokenStreamHelper = (function () {
+ function TokenStreamHelper(stream) {
+ this.stream = stream;
+ this.moveNext();
+ }
+ TokenStreamHelper.prototype.moveNext = function () {
+ do {
+ if(!this.stream.moveNext()) {
+ return false;
+ }
+ }while(this.tokenId() === TypeScript.TokenID.Comment);
+ return true;
+ };
+ TokenStreamHelper.prototype.expect = function (token) {
+ if(this.stream.tokenId() === token) {
+ this.moveNext();
+ return true;
+ }
+ return false;
+ };
+ TokenStreamHelper.prototype.skipToOffset = function (pos) {
+ while(this.tokenStartPos() < pos) {
+ if(!this.moveNext()) {
+ return false;
+ }
+ }
+ return true;
+ };
+ TokenStreamHelper.prototype.tokenId = function () {
+ return this.stream.tokenId();
+ };
+ TokenStreamHelper.prototype.tokenStartPos = function () {
+ return this.stream.tokenStartPos();
+ };
+ TokenStreamHelper.prototype.tokenEndPos = function () {
+ return this.stream.tokenEndPos();
+ };
+ return TokenStreamHelper;
+ })();
+ Services.TokenStreamHelper = TokenStreamHelper;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var BraceMatchingManager = (function () {
+ function BraceMatchingManager(scriptSyntaxAST) {
+ this.scriptSyntaxAST = scriptSyntaxAST;
+ }
+ BraceMatchingManager.prototype.getBraceMatchingAtPosition = function (position) {
+ var openBraces = "{([";
+ var openBracesTokens = [
+ TypeScript.TokenID.OpenBrace,
+ TypeScript.TokenID.OpenParen,
+ TypeScript.TokenID.OpenBracket
+ ];
+ var closeBraces = "})]";
+ var closeBracesTokens = [
+ TypeScript.TokenID.CloseBrace,
+ TypeScript.TokenID.CloseParen,
+ TypeScript.TokenID.CloseBracket
+ ];
+ var result = new Array();
+ var character = this.scriptSyntaxAST.getSourceText().getText(position, position + 1);
+ var openBraceIndex = openBraces.indexOf(character);
+ if(openBraceIndex >= 0) {
+ var closeBracePos = this.getMatchingBraceForward(position, openBracesTokens[openBraceIndex], closeBracesTokens[openBraceIndex]);
+ if(closeBracePos >= 0) {
+ var range1 = new Services.TextRange(position, position + 1);
+ var range2 = new Services.TextRange(closeBracePos, closeBracePos + 1);
+ result.push(range1, range2);
+ }
+ }
+ character = this.scriptSyntaxAST.getSourceText().getText(position - 1, position);
+ var closeBraceIndex = closeBraces.indexOf(character);
+ if(closeBraceIndex >= 0) {
+ var openBracePos = this.getMatchingBraceBackward(position - 1, closeBracesTokens[closeBraceIndex], openBracesTokens[closeBraceIndex]);
+ if(openBracePos >= 0) {
+ var range1 = new Services.TextRange(position - 1, position);
+ var range2 = new Services.TextRange(openBracePos, openBracePos + 1);
+ result.push(range1, range2);
+ }
+ }
+ return result;
+ };
+ BraceMatchingManager.prototype.getMatchingBraceForward = function (position, openToken, closeToken) {
+ var tokenStream = this.scriptSyntaxAST.getTokenStream();
+ var balanceCount = 0;
+ var foundOpenToken = false;
+ while(tokenStream.moveNext()) {
+ if(tokenStream.tokenStartPos() === position) {
+ if(tokenStream.tokenId() === openToken) {
+ foundOpenToken = true;
+ } else {
+ break;
+ }
+ }
+ if(foundOpenToken) {
+ if(tokenStream.tokenId() === openToken) {
+ balanceCount++;
+ } else if(tokenStream.tokenId() === closeToken) {
+ balanceCount--;
+ if(balanceCount === 0) {
+ return tokenStream.tokenStartPos();
+ }
+ }
+ }
+ }
+ return -1;
+ };
+ BraceMatchingManager.prototype.getMatchingBraceBackward = function (position, closeToken, openToken) {
+ var tokenStream = this.scriptSyntaxAST.getTokenStream();
+ var openTokenPositions = [];
+ var foundOpenToken = false;
+ while(tokenStream.moveNext()) {
+ if(tokenStream.tokenStartPos() > position) {
+ break;
+ }
+ if(tokenStream.tokenStartPos() === position && tokenStream.tokenId() === closeToken) {
+ if(openTokenPositions.length > 0) {
+ return openTokenPositions[openTokenPositions.length - 1];
+ }
+ break;
+ }
+ if(tokenStream.tokenId() === openToken) {
+ openTokenPositions.push(tokenStream.tokenStartPos());
+ } else if(tokenStream.tokenId() === closeToken) {
+ if(openTokenPositions.length > 0) {
+ openTokenPositions.pop();
+ }
+ }
+ }
+ return -1;
+ };
+ return BraceMatchingManager;
+ })();
+ Services.BraceMatchingManager = BraceMatchingManager;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var SymbolArraySet = (function () {
+ function SymbolArraySet() {
+ this.rtti = SymbolArraySet.rtti_id;
+ this.values = [];
+ }
+ SymbolArraySet.rtti_id = {
+ id: "Services.SymbolArraySet"
+ };
+ SymbolArraySet.prototype.add = function (sym) {
+ if(this.contains(sym)) {
+ return false;
+ }
+ this.values.push(sym);
+ return true;
+ };
+ SymbolArraySet.prototype.contains = function (sym) {
+ return this.values.indexOf(sym) >= 0;
+ };
+ SymbolArraySet.prototype.forEach = function (callback) {
+ this.values.forEach(callback);
+ };
+ SymbolArraySet.prototype.getAll = function () {
+ return this.values;
+ };
+ return SymbolArraySet;
+ })();
+ var SymbolSet = (function () {
+ function SymbolSet() {
+ this.table = new TypeScript.StringHashTable();
+ }
+ SymbolSet.prototype.isSymbolArraySet = function (value) {
+ return value.rtti === SymbolArraySet.rtti_id;
+ };
+ SymbolSet.prototype.add = function (sym) {
+ var key = sym.name;
+ var element = this.table.lookup(key);
+ if(element === null) {
+ this.table.add(key, sym);
+ return true;
+ } else if(this.isSymbolArraySet(element)) {
+ return (element).add(sym);
+ } else {
+ var value = element;
+ if(value === sym) {
+ return false;
+ }
+ var arraySet = new SymbolArraySet();
+ arraySet.add(value);
+ arraySet.add(sym);
+ this.table.addOrUpdate(key, arraySet);
+ return true;
+ }
+ };
+ SymbolSet.prototype.contains = function (sym) {
+ var key = sym.name;
+ var element = this.table.lookup(key);
+ if(element === null) {
+ return false;
+ } else if(this.isSymbolArraySet(element)) {
+ return (element).contains(sym);
+ } else {
+ var value = element;
+ return (value === sym);
+ }
+ };
+ SymbolSet.prototype.isEmpty = function () {
+ return this.table.count() === 0;
+ };
+ SymbolSet.prototype.getAll = function () {
+ var result = [];
+ this.forEach(function (x) {
+ result.push(x);
+ });
+ return result;
+ };
+ SymbolSet.prototype.forEach = function (callback) {
+ var _this = this;
+ this.table.map(function (key, element, ctx) {
+ if(element === null) {
+ } else if(_this.isSymbolArraySet(element)) {
+ (element).forEach(callback);
+ } else {
+ callback(element);
+ }
+ }, null);
+ };
+ SymbolSet.prototype.union = function (other) {
+ var _this = this;
+ other.getAll().forEach(function (x) {
+ _this.add(x);
+ });
+ };
+ return SymbolSet;
+ })();
+ Services.SymbolSet = SymbolSet;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var SymbolTree = (function () {
+ function SymbolTree(host) {
+ this.host = host;
+ this._allTypes = null;
+ }
+ SymbolTree.prototype.findBaseTypesTransitiveClosure = function (sym) {
+ var closure = new Services.SymbolSet();
+ var lastSet = new Services.SymbolSet();
+ lastSet.add(sym);
+ while(!lastSet.isEmpty()) {
+ closure.union(lastSet);
+ lastSet = this.findBaseTypes(closure, lastSet);
+ }
+ return closure;
+ };
+ SymbolTree.prototype.findDerivedTypesTransitiveClosure = function (sym) {
+ var closure = new Services.SymbolSet();
+ var lastSet = new Services.SymbolSet();
+ lastSet.add(sym);
+ while(!lastSet.isEmpty()) {
+ closure.union(lastSet);
+ lastSet = this.findDerivedTypes(closure, lastSet);
+ }
+ return closure;
+ };
+ SymbolTree.prototype.getOverride = function (container, memberSym) {
+ var members = null;
+ if(this.isClass(container)) {
+ members = container.type.instanceType.members;
+ } else if(this.isInterface(container)) {
+ members = container.type.members;
+ }
+ if(members == null) {
+ return null;
+ }
+ var override = members.allMembers.lookup(memberSym.name);
+ if(override == null) {
+ return null;
+ }
+ if((this.isMethod(memberSym) === this.isMethod(override)) && (this.isField(memberSym) === this.isField(override)) && (this.isStatic(memberSym) === this.isStatic(override))) {
+ return override;
+ }
+ return null;
+ };
+ SymbolTree.prototype.getAllTypes = function () {
+ var _this = this;
+ if(this._allTypes === null) {
+ var result = new Services.SymbolSet();
+ this.host.getScripts().forEach(function (script) {
+ TypeScript.walkAST(script, function (path, walker) {
+ if(path.isNameOfClass() || path.isNameOfInterface()) {
+ var sym = (path.ast()).sym;
+ if(sym != null) {
+ if(sym.kind() === TypeScript.SymbolKind.Type) {
+ var typeSym = sym;
+ if(_this.isClass(typeSym) || _this.isInterface(typeSym)) {
+ result.add(typeSym);
+ }
+ }
+ }
+ }
+ if(path.isBodyOfFunction()) {
+ walker.options.goChildren = false;
+ }
+ });
+ });
+ this._allTypes = result.getAll();
+ }
+ return this._allTypes;
+ };
+ SymbolTree.prototype.findBaseTypes = function (closure, lastSet) {
+ var _this = this;
+ var result = new Services.SymbolSet();
+ var symsArray = lastSet.getAll();
+ symsArray.forEach(function (sym) {
+ if(sym.kind() === TypeScript.SymbolKind.Type) {
+ var type = (sym).type;
+ if(type !== null) {
+ if(type.instanceType != null) {
+ type = type.instanceType;
+ }
+ _this.addBaseTypes(closure, result, type.implementsList);
+ _this.addBaseTypes(closure, result, type.extendsList);
+ }
+ }
+ });
+ return result;
+ };
+ SymbolTree.prototype.findDerivedTypes = function (alreadyFound, baseSymbols) {
+ var _this = this;
+ var result = new Services.SymbolSet();
+ this.getAllTypes().forEach(function (candidate) {
+ if(!alreadyFound.contains(candidate)) {
+ if(candidate.kind() === TypeScript.SymbolKind.Type) {
+ var type = (candidate).type;
+ if(type !== null) {
+ if(type.instanceType != null) {
+ type = type.instanceType;
+ }
+ var emptySet = new Services.SymbolSet();
+ var baseTypes = new Services.SymbolSet();
+ _this.addBaseTypes(emptySet, baseTypes, type.implementsList);
+ _this.addBaseTypes(emptySet, baseTypes, type.extendsList);
+ baseTypes.getAll().forEach(function (baseType) {
+ if(baseSymbols.contains(baseType)) {
+ result.add(candidate);
+ }
+ });
+ }
+ }
+ }
+ });
+ return result;
+ };
+ SymbolTree.prototype.addBaseTypes = function (closure, syms, bases) {
+ var _this = this;
+ if(bases == null) {
+ return;
+ }
+ bases.forEach(function (base) {
+ if(base.symbol !== null) {
+ if(!closure.contains(base.symbol)) {
+ if(_this.isDefinition(base.symbol)) {
+ syms.add(base.symbol);
+ }
+ }
+ }
+ });
+ };
+ SymbolTree.prototype.isDefinition = function (sym) {
+ return this.isClass(sym) || this.isInterface(sym);
+ };
+ SymbolTree.prototype.isClass = function (sym) {
+ return sym != null && sym.kind() == TypeScript.SymbolKind.Type && (sym).isClass();
+ };
+ SymbolTree.prototype.isInterface = function (sym) {
+ return sym != null && sym.kind() == TypeScript.SymbolKind.Type && sym.declAST != null && sym.declAST.nodeType === TypeScript.NodeType.InterfaceDeclaration;
+ };
+ SymbolTree.prototype.isMethod = function (sym) {
+ return sym != null && sym.kind() === TypeScript.SymbolKind.Type && (sym).isMethod;
+ };
+ SymbolTree.prototype.isField = function (sym) {
+ return sym != null && sym.kind() === TypeScript.SymbolKind.Field;
+ };
+ SymbolTree.prototype.isStatic = function (sym) {
+ return sym != null && sym.isStatic();
+ };
+ return SymbolTree;
+ })();
+ Services.SymbolTree = SymbolTree;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var OverridesCollector = (function () {
+ function OverridesCollector(symbolTree) {
+ this.symbolTree = symbolTree;
+ }
+ OverridesCollector.prototype.findMemberOverrides = function (memberSym) {
+ return this.findMemberOverridesImpl(memberSym, true, true);
+ };
+ OverridesCollector.prototype.findImplementors = function (sym) {
+ if(this.symbolTree.isClass(sym) || this.symbolTree.isInterface(sym)) {
+ return this.symbolTree.findDerivedTypesTransitiveClosure(sym);
+ } else if(this.symbolTree.isMethod(sym) || this.symbolTree.isField(sym)) {
+ return this.findMemberOverridesImpl(sym, false, true);
+ } else {
+ return new Services.SymbolSet();
+ }
+ };
+ OverridesCollector.prototype.findMemberOverridesImpl = function (memberSym, lookInBases, lookInDerived) {
+ var _this = this;
+ var result = new Services.SymbolSet();
+ result.add(memberSym);
+ if(memberSym.container === null) {
+ return result;
+ }
+ var baseTypes = (lookInBases ? this.symbolTree.findBaseTypesTransitiveClosure(memberSym.container) : new Services.SymbolSet());
+ var derivedTypes = (lookInDerived ? this.symbolTree.findDerivedTypesTransitiveClosure(memberSym.container) : new Services.SymbolSet());
+ var allTypes = new Services.SymbolSet();
+ allTypes.add(memberSym.container);
+ allTypes.union(baseTypes);
+ allTypes.union(derivedTypes);
+ allTypes.getAll().forEach(function (x) {
+ var override = _this.symbolTree.getOverride(x, memberSym);
+ if(override !== null) {
+ result.add(override);
+ }
+ });
+ return result;
+ };
+ return OverridesCollector;
+ })();
+ Services.OverridesCollector = OverridesCollector;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ var LanguageServiceShimHostAdapter = (function () {
+ function LanguageServiceShimHostAdapter(shimHost) {
+ this.shimHost = shimHost;
+ }
+ LanguageServiceShimHostAdapter.prototype.information = function () {
+ return this.shimHost.information();
+ };
+ LanguageServiceShimHostAdapter.prototype.debug = function () {
+ return this.shimHost.debug();
+ };
+ LanguageServiceShimHostAdapter.prototype.warning = function () {
+ return this.shimHost.warning();
+ };
+ LanguageServiceShimHostAdapter.prototype.error = function () {
+ return this.shimHost.error();
+ };
+ LanguageServiceShimHostAdapter.prototype.fatal = function () {
+ return this.shimHost.fatal();
+ };
+ LanguageServiceShimHostAdapter.prototype.log = function (s) {
+ this.shimHost.log(s);
+ };
+ LanguageServiceShimHostAdapter.prototype.getCompilationSettings = function () {
+ var settingsJson = this.shimHost.getCompilationSettings();
+ if(settingsJson == null || settingsJson == "") {
+ return null;
+ }
+ var settings = JSON.parse(settingsJson);
+ return settings;
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptCount = function () {
+ return this.shimHost.getScriptCount();
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptId = function (scriptIndex) {
+ return this.shimHost.getScriptId(scriptIndex);
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptSourceText = function (scriptIndex, start, end) {
+ return this.shimHost.getScriptSourceText(scriptIndex, start, end);
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptSourceLength = function (scriptIndex) {
+ return this.shimHost.getScriptSourceLength(scriptIndex);
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptIsResident = function (scriptIndex) {
+ return this.shimHost.getScriptIsResident(scriptIndex);
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptVersion = function (scriptIndex) {
+ return this.shimHost.getScriptVersion(scriptIndex);
+ };
+ LanguageServiceShimHostAdapter.prototype.getScriptEditRangeSinceVersion = function (scriptIndex, scriptVersion) {
+ var rangeText = this.shimHost.getScriptEditRangeSinceVersion(scriptIndex, scriptVersion);
+ if(rangeText === null || rangeText === "") {
+ return null;
+ }
+ var minLimDeltaString = rangeText.split(",");
+ return new TypeScript.ScriptEditRange(parseInt(minLimDeltaString[0]), parseInt(minLimDeltaString[1]), parseInt(minLimDeltaString[2]));
+ };
+ return LanguageServiceShimHostAdapter;
+ })();
+ Services.LanguageServiceShimHostAdapter = LanguageServiceShimHostAdapter;
+ function simpleForwardCall(logger, actionDescription, action) {
+ logger.log(actionDescription);
+ var start = Date.now();
+ var result = action();
+ var end = Date.now();
+ logger.log(actionDescription + " completed in " + (end - start) + " msec");
+ if(typeof (result) === "string") {
+ var str = result;
+ logger.log(" result.length=" + str.length + ", result=\"" + TypeScript.stringToLiteral(str, 128) + (str.length > 128 ? "..." : "") + "\"");
+ }
+ return result;
+ }
+ Services.simpleForwardCall = simpleForwardCall;
+ function forwardCall(logger, actionDescription, action, throwOnError) {
+ if (typeof throwOnError === "undefined") { throwOnError = false; }
+ try {
+ return simpleForwardCall(logger, actionDescription, action);
+ } catch (err) {
+ Services.logInternalError(logger, err);
+ if(throwOnError) {
+ throw err;
+ }
+ return "##ERROR##" + err.name + "##" + err.message;
+ }
+ }
+ Services.forwardCall = forwardCall;
+ function forwardJSONCall(logger, actionDescription, action) {
+ try {
+ return simpleForwardCall(logger, actionDescription, action);
+ } catch (err) {
+ Services.logInternalError(logger, err);
+ return _errorToJSON(err);
+ }
+ }
+ Services.forwardJSONCall = forwardJSONCall;
+ function _resultToJSON(result) {
+ return '{"result":' + JSON.stringify(result) + "}";
+ }
+ function _errorToJSON(err) {
+ return '{"error":' + JSON.stringify(err) + "}";
+ }
+ var LanguageServiceShim = (function () {
+ function LanguageServiceShim(host, languageService) {
+ this.host = host;
+ this.languageService = languageService;
+ this.logger = this.host;
+ }
+ LanguageServiceShim.prototype.forwardCall = function (actionDescription, action, throwOnError) {
+ if (typeof throwOnError === "undefined") { throwOnError = false; }
+ return Services.forwardCall(this.logger, actionDescription, action, throwOnError);
+ };
+ LanguageServiceShim.prototype.forwardJSONCall = function (actionDescription, action) {
+ return Services.forwardJSONCall(this.logger, actionDescription, action);
+ };
+ LanguageServiceShim.prototype.dispose = function (dummy) {
+ this.logger.log("dispose()");
+ this.languageService = null;
+ this.logger = null;
+ };
+ LanguageServiceShim.prototype.refresh = function (throwOnError) {
+ var _this = this;
+ this.forwardCall("refresh(" + throwOnError + ")", function () {
+ _this.languageService.refresh();
+ return null;
+ }, throwOnError);
+ };
+ LanguageServiceShim.prototype.getErrors = function (maxCount) {
+ var _this = this;
+ return this.forwardJSONCall("getErrors(" + maxCount + ")", function () {
+ var errors = _this.languageService.getErrors(maxCount);
+ return _resultToJSON(errors);
+ });
+ };
+ LanguageServiceShim.prototype.getScriptErrors = function (fileName, maxCount) {
+ var _this = this;
+ return this.forwardJSONCall("getScriptErrors(" + maxCount + ")", function () {
+ var errors = _this.languageService.getScriptErrors(fileName, maxCount);
+ return _resultToJSON(errors);
+ });
+ };
+ LanguageServiceShim.prototype.getTypeAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getTypeAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var typeInfo = _this.languageService.getTypeAtPosition(fileName, pos);
+ return _resultToJSON(typeInfo);
+ });
+ };
+ LanguageServiceShim.prototype.getNameOrDottedNameSpan = function (fileName, startPos, endPos) {
+ var _this = this;
+ return this.forwardJSONCall("getNameOrDottedNameSpan(\"" + fileName + "\", " + startPos + ", " + endPos + ")", function () {
+ var spanInfo = _this.languageService.getNameOrDottedNameSpan(fileName, startPos, endPos);
+ return _resultToJSON(spanInfo);
+ });
+ };
+ LanguageServiceShim.prototype.getBreakpointStatementAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getBreakpointStatementAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var spanInfo = _this.languageService.getBreakpointStatementAtPosition(fileName, pos);
+ return _resultToJSON(spanInfo);
+ });
+ };
+ LanguageServiceShim.prototype.getSignatureAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getSignatureAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var signatureInfo = _this.languageService.getSignatureAtPosition(fileName, pos);
+ return _resultToJSON(signatureInfo);
+ });
+ };
+ LanguageServiceShim.prototype.getDefinitionAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardCall("getDefinitionAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var definition = _this.languageService.getDefinitionAtPosition(fileName, pos);
+ var result = "";
+ if(definition !== null) {
+ result = definition.unitIndex + '\t' + definition.minChar + '\t' + definition.limChar + '\t' + definition.kind + '\t' + definition.name + '\t' + definition.containerKind + '\t' + definition.containerName;
+ }
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getBraceMatchingAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getBraceMatchingAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var textRanges = _this.languageService.getBraceMatchingAtPosition(fileName, pos);
+ return _resultToJSON(textRanges);
+ });
+ };
+ LanguageServiceShim.prototype.getSmartIndentAtLineNumber = function (fileName, lineNumber, options) {
+ var _this = this;
+ return this.forwardJSONCall("getSmartIndentAtLineNumber(\"" + fileName + "\", " + lineNumber + ")", function () {
+ var localOptions = JSON.parse(options);
+ var columnOffset = _this.languageService.getSmartIndentAtLineNumber(fileName, lineNumber, localOptions);
+ return _resultToJSON({
+ value: columnOffset
+ });
+ });
+ };
+ LanguageServiceShim.prototype.getReferencesAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getReferencesAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var entries = _this.languageService.getReferencesAtPosition(fileName, pos);
+ return _this._referencesToResult(entries);
+ });
+ };
+ LanguageServiceShim.prototype.getOccurrencesAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardCall("getOccurrencesAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var entries = _this.languageService.getOccurrencesAtPosition(fileName, pos);
+ return _this._referencesToResult(entries);
+ });
+ };
+ LanguageServiceShim.prototype.getImplementorsAtPosition = function (fileName, pos) {
+ var _this = this;
+ return this.forwardJSONCall("getImplementorsAtPosition(\"" + fileName + "\", " + pos + ")", function () {
+ var entries = _this.languageService.getImplementorsAtPosition(fileName, pos);
+ return _this._referencesToResult(entries);
+ });
+ };
+ LanguageServiceShim.prototype._referencesToResult = function (entries) {
+ var result = "";
+ for(var i = 0; i < entries.length; i++) {
+ var entry = entries[i];
+ result += entry.unitIndex + " " + entry.ast.minChar + " " + entry.ast.limChar + " " + entry.isWriteAccess + "\n";
+ }
+ return result;
+ };
+ LanguageServiceShim.prototype.getCompletionsAtPosition = function (fileName, pos, isMemberCompletion) {
+ var _this = this;
+ return this.forwardJSONCall("getCompletionsAtPosition(\"" + fileName + "\", " + pos + ", " + isMemberCompletion + ")", function () {
+ var completion = _this.languageService.getCompletionsAtPosition(fileName, pos, isMemberCompletion);
+ var result = _resultToJSON(completion);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getFormattingEditsForRange = function (fileName, minChar, limChar, options) {
+ var _this = this;
+ return this.forwardJSONCall("getFormattingEditsForRange(\"" + fileName + "\", " + minChar + ", " + limChar + ")", function () {
+ var localOptions = JSON.parse(options);
+ var edits = _this.languageService.getFormattingEditsForRange(fileName, minChar, limChar, localOptions);
+ var result = _resultToJSON(edits);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getFormattingEditsForDocument = function (fileName, minChar, limChar, options) {
+ var _this = this;
+ return this.forwardJSONCall("getFormattingEditsForDocument(\"" + fileName + "\", " + minChar + ", " + limChar + ")", function () {
+ var localOptions = JSON.parse(options);
+ var edits = _this.languageService.getFormattingEditsForDocument(fileName, minChar, limChar, localOptions);
+ var result = _resultToJSON(edits);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getFormattingEditsOnPaste = function (fileName, minChar, limChar, options) {
+ var _this = this;
+ return this.forwardJSONCall("getFormattingEditsOnPaste(\"" + fileName + "\", " + minChar + ", " + limChar + ")", function () {
+ var localOptions = JSON.parse(options);
+ var edits = _this.languageService.getFormattingEditsOnPaste(fileName, minChar, limChar, localOptions);
+ var result = _resultToJSON(edits);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getFormattingEditsAfterKeystroke = function (fileName, position, key, options) {
+ var _this = this;
+ return this.forwardJSONCall("getFormattingEditsAfterKeystroke(\"" + fileName + "\", " + position + ", \"" + key + "\")", function () {
+ var localOptions = JSON.parse(options);
+ var edits = _this.languageService.getFormattingEditsAfterKeystroke(fileName, position, key, localOptions);
+ var result = _resultToJSON(edits);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getNavigateToItems = function (searchValue) {
+ var _this = this;
+ return this.forwardCall("getNavigateToItems(\"" + searchValue + "\")", function () {
+ var items = _this.languageService.getNavigateToItems(searchValue);
+ var result = _this._navigateToItemsToString(items);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getScriptLexicalStructure = function (fileName) {
+ var _this = this;
+ return this.forwardCall("getScriptLexicalStructure(\"" + fileName + "\")", function () {
+ var items = _this.languageService.getScriptLexicalStructure(fileName);
+ var result = _this._navigateToItemsToString(items);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.getOutliningRegions = function (fileName) {
+ var _this = this;
+ return this.forwardCall("getOutliningRegions(\"" + fileName + "\")", function () {
+ var items = _this.languageService.getOutliningRegions(fileName);
+ var result = _this._navigateToItemsToString(items);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype.logAST = function (fileName) {
+ var _this = this;
+ this.forwardCall("logAST(\"" + fileName + "\")", function () {
+ _this.languageService.logAST(fileName);
+ return null;
+ });
+ };
+ LanguageServiceShim.prototype.logSyntaxAST = function (fileName) {
+ var _this = this;
+ this.forwardCall("logSyntaxAST(\"" + fileName + "\")", function () {
+ _this.languageService.logSyntaxAST(fileName);
+ return null;
+ });
+ };
+ LanguageServiceShim.prototype.getEmitOutput = function (fileName) {
+ var _this = this;
+ return this.forwardJSONCall("getEmitOutput(\"" + fileName + "\")", function () {
+ var output = _this.languageService.getEmitOutput(fileName);
+ var result = _resultToJSON(output);
+ return result;
+ });
+ };
+ LanguageServiceShim.prototype._navigateToItemsToString = function (items) {
+ var result = "";
+ for(var i = 0; i < items.length; i++) {
+ var item = items[i];
+ result += item.name + "\t" + item.kind + "\t" + item.kindModifiers + "\t" + item.containerName + "\t" + item.containerKind + "\t" + item.matchKind + "\t" + item.unitIndex + "\t" + item.minChar + "\t" + item.limChar + "\n";
+ }
+ return result;
+ };
+ return LanguageServiceShim;
+ })();
+ Services.LanguageServiceShim = LanguageServiceShim;
+ var ClassifierShim = (function () {
+ function ClassifierShim(host) {
+ this.host = host;
+ this.classifier = new Services.Classifier(this.host);
+ }
+ ClassifierShim.prototype.getClassificationsForLine = function (text, lexState) {
+ var classification = this.classifier.getClassificationsForLine(text, lexState);
+ var items = classification.entries;
+ var result = "";
+ for(var i = 0; i < items.length; i++) {
+ result += items[i].length + "\n";
+ result += items[i].classification + "\n";
+ }
+ result += classification.finalLexState;
+ return result;
+ };
+ return ClassifierShim;
+ })();
+ Services.ClassifierShim = ClassifierShim;
+ var CoreServicesShim = (function () {
+ function CoreServicesShim(host) {
+ this.host = host;
+ this.logger = this.host.logger;
+ this.services = new Services.CoreServices(this.host);
+ }
+ CoreServicesShim.prototype.forwardCall = function (actionDescription, action, throwOnError) {
+ if (typeof throwOnError === "undefined") { throwOnError = false; }
+ return Services.forwardCall(this.logger, actionDescription, action, throwOnError);
+ };
+ CoreServicesShim.prototype.forwardJSONCall = function (actionDescription, action) {
+ return Services.forwardJSONCall(this.logger, actionDescription, action);
+ };
+ CoreServicesShim.prototype.getPreProcessedFileInfo = function (scriptId, sourceText) {
+ var _this = this;
+ return this.forwardJSONCall("getPreProcessedFileInfo(\"" + scriptId + "\")", function () {
+ var result = _this.services.getPreProcessedFileInfo(scriptId, sourceText);
+ return _resultToJSON(result);
+ });
+ };
+ CoreServicesShim.prototype.getDefaultCompilationSettings = function () {
+ var _this = this;
+ return this.forwardJSONCall("getDefaultCompilationSettings()", function () {
+ var result = _this.services.getDefaultCompilationSettings();
+ return _resultToJSON(result);
+ });
+ };
+ CoreServicesShim.prototype.dumpMemory = function (dummy) {
+ var _this = this;
+ return this.forwardCall("dumpMemory()", function () {
+ return _this.services.dumpMemory();
+ });
+ };
+ CoreServicesShim.prototype.getMemoryInfo = function (dummy) {
+ var _this = this;
+ return this.forwardJSONCall("getMemoryInfo()", function () {
+ var result = _this.services.getMemoryInfo();
+ return _resultToJSON(result);
+ });
+ };
+ return CoreServicesShim;
+ })();
+ Services.CoreServicesShim = CoreServicesShim;
+})(Services || (Services = {}));
+var Services;
+(function (Services) {
+ function copyDataObject(dst, src) {
+ for(var e in dst) {
+ if(typeof dst[e] == "object") {
+ copyDataObject(dst[e], src[e]);
+ } else if(typeof dst[e] != "function") {
+ dst[e] = src[e];
+ }
+ }
+ return dst;
+ }
+ Services.copyDataObject = copyDataObject;
+ function compareDataObjects(dst, src) {
+ for(var e in dst) {
+ if(typeof dst[e] == "object") {
+ if(!compareDataObjects(dst[e], src[e])) {
+ return false;
+ }
+ } else if(typeof dst[e] != "function") {
+ if(dst[e] !== src[e]) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ Services.compareDataObjects = compareDataObjects;
+ var TypeScriptServicesFactory = (function () {
+ function TypeScriptServicesFactory() { }
+ TypeScriptServicesFactory.prototype.createLanguageService = function (host) {
+ try {
+ return new Services.LanguageService(host);
+ } catch (err) {
+ Services.logInternalError(host, err);
+ throw err;
+ }
+ };
+ TypeScriptServicesFactory.prototype.createLanguageServiceShim = function (host) {
+ try {
+ var hostAdapter = new Services.LanguageServiceShimHostAdapter(host);
+ var languageService = this.createLanguageService(hostAdapter);
+ return new Services.LanguageServiceShim(host, languageService);
+ } catch (err) {
+ Services.logInternalError(host, err);
+ throw err;
+ }
+ };
+ TypeScriptServicesFactory.prototype.createClassifier = function (host) {
+ try {
+ return new Services.Classifier(host);
+ } catch (err) {
+ Services.logInternalError(host, err);
+ throw err;
+ }
+ };
+ TypeScriptServicesFactory.prototype.createClassifierShim = function (host) {
+ try {
+ return new Services.ClassifierShim(host);
+ } catch (err) {
+ Services.logInternalError(host, err);
+ throw err;
+ }
+ };
+ TypeScriptServicesFactory.prototype.createCoreServices = function (host) {
+ try {
+ return new Services.CoreServices(host);
+ } catch (err) {
+ Services.logInternalError(host.logger, err);
+ throw err;
+ }
+ };
+ TypeScriptServicesFactory.prototype.createCoreServicesShim = function (host) {
+ try {
+ return new Services.CoreServicesShim(host);
+ } catch (err) {
+ Services.logInternalError(host.logger, err);
+ throw err;
+ }
+ };
+ return TypeScriptServicesFactory;
+ })();
+ Services.TypeScriptServicesFactory = TypeScriptServicesFactory;
+})(Services || (Services = {}));
+var Formatting;
+(function (Formatting) {
+ var SnapshotSpan = (function () {
+ function SnapshotSpan(snapshot, span) {
+ this.snapshot = snapshot;
+ this.span = span;
+ this._startPoint = null;
+ this._endPoint = null;
+ }
+ SnapshotSpan.prototype.start = function () {
+ if(this._startPoint == null) {
+ this._startPoint = new SnapshotPoint(this.snapshot, this.span.start());
+ }
+ return this._startPoint;
+ };
+ SnapshotSpan.prototype.end = function () {
+ if(this._endPoint == null) {
+ this._endPoint = new SnapshotPoint(this.snapshot, this.span.end());
+ }
+ return this._endPoint;
+ };
+ SnapshotSpan.prototype.startPosition = function () {
+ return this.span.start();
+ };
+ SnapshotSpan.prototype.endPosition = function () {
+ return this.span.end();
+ };
+ SnapshotSpan.prototype.GetText = function () {
+ return this.snapshot.GetText(this.span);
+ };
+ SnapshotSpan.prototype.IsEmpty = function () {
+ return this.span.length() === 0;
+ };
+ SnapshotSpan.prototype.OverlapsWith = function (spanArg) {
+ return this.span.OverlapsWith(spanArg);
+ };
+ SnapshotSpan.prototype.Intersection = function (simpleSpan) {
+ var nullable = this.span.Intersection(simpleSpan);
+ if(nullable !== null) {
+ return new SnapshotSpan(this.snapshot, nullable);
+ }
+ return null;
+ };
+ return SnapshotSpan;
+ })();
+ Formatting.SnapshotSpan = SnapshotSpan;
+ var SnapshotPoint = (function () {
+ function SnapshotPoint(snapshot, position) {
+ this.snapshot = snapshot;
+ this.position = position;
+ }
+ SnapshotPoint.prototype.GetContainingLine = function () {
+ return this.snapshot.GetLineFromPosition(this.position);
+ };
+ SnapshotPoint.prototype.Add = function (offset) {
+ return new SnapshotPoint(this.snapshot, this.position + offset);
+ };
+ return SnapshotPoint;
+ })();
+ Formatting.SnapshotPoint = SnapshotPoint;
+ var FileAuthoringProxy = (function () {
+ function FileAuthoringProxy(scriptSyntaxAST) {
+ this.scriptSyntaxAST = scriptSyntaxAST;
+ }
+ FileAuthoringProxy.prototype.GetASTCursor = function () {
+ return new AuthorParseNodeCursor(this);
+ };
+ return FileAuthoringProxy;
+ })();
+ Formatting.FileAuthoringProxy = FileAuthoringProxy;
+ var AuthorParseNodeCursor = (function () {
+ function AuthorParseNodeCursor(fileAuthoringProxy) {
+ this.fileAuthoringProxy = fileAuthoringProxy;
+ this.logger = this.fileAuthoringProxy.scriptSyntaxAST.getLogger();
+ this.path = new TypeScript.AstPath();
+ }
+ AuthorParseNodeCursor.prototype.fixupPath = function (newPath) {
+ var temp = new TypeScript.AstPath();
+ for(var i = 0; i < newPath.count(); i++) {
+ temp.push(newPath.asts[i]);
+ if(temp.isBodyOfCase()) {
+ var fakeBlock = this.mapBodyOfCase(temp.ast());
+ var previousBody = temp.pop();
+ temp.push(fakeBlock);
+ temp.push(previousBody);
+ }
+ }
+ return temp;
+ };
+ AuthorParseNodeCursor.prototype.mapNodeType = function (path) {
+ var nodeType = path.ast().nodeType;
+ var mapList = function () {
+ if(path.isBodyOfScript() || path.isBodyOfModule() || path.isBodyOfClass() || path.isBodyOfInterface() || path.isBodyOfFor() || path.isBodyOfForIn() || path.isBodyOfWhile() || path.isBodyOfDoWhile() || path.isBodyOfTry() || path.isBodyOfCatch() || path.isBodyOfFinally() || path.isBodyOfFunction() || path.isBodyOfWith() || path.isBodyOfSwitch() || false) {
+ return AuthorParseNodeKind.apnkBlock;
+ } else {
+ return AuthorParseNodeKind.apnkList;
+ }
+ };
+ switch(nodeType) {
+ case TypeScript.NodeType.None:
+ return AuthorParseNodeKind.apnkEmptyNode;
+ case TypeScript.NodeType.Empty:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.EmptyExpr:
+ return AuthorParseNodeKind.apnkEmptyNode;
+ case TypeScript.NodeType.True:
+ return AuthorParseNodeKind.apnkTrue;
+ case TypeScript.NodeType.False:
+ return AuthorParseNodeKind.apnkFalse;
+ case TypeScript.NodeType.This:
+ return AuthorParseNodeKind.apnkThis;
+ case TypeScript.NodeType.Super:
+ return AuthorParseNodeKind.apnkThis;
+ case TypeScript.NodeType.QString:
+ return AuthorParseNodeKind.apnkStr;
+ case TypeScript.NodeType.Regex:
+ return AuthorParseNodeKind.apnkRegExp;
+ case TypeScript.NodeType.Null:
+ return AuthorParseNodeKind.apnkNull;
+ case TypeScript.NodeType.ArrayLit:
+ return AuthorParseNodeKind.apnkArray;
+ case TypeScript.NodeType.ObjectLit:
+ return AuthorParseNodeKind.apnkObject;
+ case TypeScript.NodeType.Void:
+ return AuthorParseNodeKind.apnkNull;
+ case TypeScript.NodeType.Comma:
+ return AuthorParseNodeKind.apnkComma;
+ case TypeScript.NodeType.Pos:
+ return AuthorParseNodeKind.apnkPos;
+ case TypeScript.NodeType.Neg:
+ return AuthorParseNodeKind.apnkNeg;
+ case TypeScript.NodeType.Delete:
+ return AuthorParseNodeKind.apnkDelete;
+ case TypeScript.NodeType.Await:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.In:
+ return AuthorParseNodeKind.apnkIn;
+ case TypeScript.NodeType.Dot:
+ return AuthorParseNodeKind.apnkDot;
+ case TypeScript.NodeType.From:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.Is:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.InstOf:
+ return AuthorParseNodeKind.apnkInstOf;
+ case TypeScript.NodeType.Typeof:
+ return AuthorParseNodeKind.apnkTypeof;
+ case TypeScript.NodeType.NumberLit:
+ return AuthorParseNodeKind.apnkInt;
+ case TypeScript.NodeType.Name:
+ return AuthorParseNodeKind.apnkName;
+ case TypeScript.NodeType.TypeRef:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.Index:
+ return AuthorParseNodeKind.apnkIndex;
+ case TypeScript.NodeType.Call:
+ return AuthorParseNodeKind.apnkCall;
+ case TypeScript.NodeType.New:
+ return AuthorParseNodeKind.apnkNew;
+ case TypeScript.NodeType.Asg:
+ return AuthorParseNodeKind.apnkAsg;
+ case TypeScript.NodeType.AsgAdd:
+ return AuthorParseNodeKind.apnkAsgAdd;
+ case TypeScript.NodeType.AsgSub:
+ return AuthorParseNodeKind.apnkAsgDiv;
+ case TypeScript.NodeType.AsgDiv:
+ return AuthorParseNodeKind.apnkAsgMul;
+ case TypeScript.NodeType.AsgMul:
+ return AuthorParseNodeKind.apnkAsgMul;
+ case TypeScript.NodeType.AsgMod:
+ return AuthorParseNodeKind.apnkAsgMod;
+ case TypeScript.NodeType.AsgAnd:
+ return AuthorParseNodeKind.apnkAsgAnd;
+ case TypeScript.NodeType.AsgXor:
+ return AuthorParseNodeKind.apnkAsgXor;
+ case TypeScript.NodeType.AsgOr:
+ return AuthorParseNodeKind.apnkAsgOr;
+ case TypeScript.NodeType.AsgLsh:
+ return AuthorParseNodeKind.apnkAsgLsh;
+ case TypeScript.NodeType.AsgRsh:
+ return AuthorParseNodeKind.apnkAsgRsh;
+ case TypeScript.NodeType.AsgRs2:
+ return AuthorParseNodeKind.apnkAsgRs2;
+ case TypeScript.NodeType.ConditionalExpression:
+ return AuthorParseNodeKind.apnkQmark;
+ case TypeScript.NodeType.LogOr:
+ return AuthorParseNodeKind.apnkLogOr;
+ case TypeScript.NodeType.LogAnd:
+ return AuthorParseNodeKind.apnkLogAnd;
+ case TypeScript.NodeType.Or:
+ return AuthorParseNodeKind.apnkOr;
+ case TypeScript.NodeType.Xor:
+ return AuthorParseNodeKind.apnkXor;
+ case TypeScript.NodeType.And:
+ return AuthorParseNodeKind.apnkAnd;
+ case TypeScript.NodeType.Eq:
+ return AuthorParseNodeKind.apnkEq;
+ case TypeScript.NodeType.Ne:
+ return AuthorParseNodeKind.apnkNe;
+ case TypeScript.NodeType.Eqv:
+ return AuthorParseNodeKind.apnkEqv;
+ case TypeScript.NodeType.NEqv:
+ return AuthorParseNodeKind.apnkNEqv;
+ case TypeScript.NodeType.Lt:
+ return AuthorParseNodeKind.apnkLt;
+ case TypeScript.NodeType.Le:
+ return AuthorParseNodeKind.apnkLe;
+ case TypeScript.NodeType.Gt:
+ return AuthorParseNodeKind.apnkGt;
+ case TypeScript.NodeType.Ge:
+ return AuthorParseNodeKind.apnkGe;
+ case TypeScript.NodeType.Add:
+ return AuthorParseNodeKind.apnkAdd;
+ case TypeScript.NodeType.Sub:
+ return AuthorParseNodeKind.apnkSub;
+ case TypeScript.NodeType.Mul:
+ return AuthorParseNodeKind.apnkMul;
+ case TypeScript.NodeType.Div:
+ return AuthorParseNodeKind.apnkDiv;
+ case TypeScript.NodeType.Mod:
+ return AuthorParseNodeKind.apnkMod;
+ case TypeScript.NodeType.Lsh:
+ return AuthorParseNodeKind.apnkLsh;
+ case TypeScript.NodeType.Rsh:
+ return AuthorParseNodeKind.apnkRsh;
+ case TypeScript.NodeType.Rs2:
+ return AuthorParseNodeKind.apnkRs2;
+ case TypeScript.NodeType.Not:
+ return AuthorParseNodeKind.apnkNot;
+ case TypeScript.NodeType.LogNot:
+ return AuthorParseNodeKind.apnkLogNot;
+ case TypeScript.NodeType.IncPre:
+ return AuthorParseNodeKind.apnkIncPre;
+ case TypeScript.NodeType.DecPre:
+ return AuthorParseNodeKind.apnkDecPre;
+ case TypeScript.NodeType.IncPost:
+ return AuthorParseNodeKind.apnkIncPost;
+ case TypeScript.NodeType.DecPost:
+ return AuthorParseNodeKind.apnkDecPost;
+ case TypeScript.NodeType.TypeAssertion:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.FuncDecl:
+ return AuthorParseNodeKind.apnkFncDecl;
+ case TypeScript.NodeType.Member:
+ return AuthorParseNodeKind.apnkMember;
+ case TypeScript.NodeType.VarDecl:
+ return AuthorParseNodeKind.apnkVarDecl;
+ case TypeScript.NodeType.ArgDecl:
+ return AuthorParseNodeKind.apnkVarDecl;
+ case TypeScript.NodeType.Return:
+ return AuthorParseNodeKind.apnkReturn;
+ case TypeScript.NodeType.Break:
+ return AuthorParseNodeKind.apnkBreak;
+ case TypeScript.NodeType.Continue:
+ return AuthorParseNodeKind.apnkContinue;
+ case TypeScript.NodeType.Throw:
+ return AuthorParseNodeKind.apnkThrow;
+ case TypeScript.NodeType.For:
+ return AuthorParseNodeKind.apnkFor;
+ case TypeScript.NodeType.ForIn:
+ return AuthorParseNodeKind.apnkForIn;
+ case TypeScript.NodeType.If:
+ return AuthorParseNodeKind.apnkIf;
+ case TypeScript.NodeType.While:
+ return AuthorParseNodeKind.apnkWhile;
+ case TypeScript.NodeType.DoWhile:
+ return AuthorParseNodeKind.apnkDoWhile;
+ case TypeScript.NodeType.Block:
+ return (path.ast()).isStatementBlock ? AuthorParseNodeKind.apnkBlock : AuthorParseNodeKind.apnkVarDeclList;
+ case TypeScript.NodeType.Case:
+ return AuthorParseNodeKind.apnkCase;
+ case TypeScript.NodeType.Switch:
+ return AuthorParseNodeKind.apnkSwitch;
+ case TypeScript.NodeType.Try:
+ return AuthorParseNodeKind.apnkTry;
+ case TypeScript.NodeType.TryCatch:
+ return AuthorParseNodeKind.apnkTryCatch;
+ case TypeScript.NodeType.TryFinally:
+ return AuthorParseNodeKind.apnkTryFinally;
+ case TypeScript.NodeType.Finally:
+ return AuthorParseNodeKind.apnkFinally;
+ case TypeScript.NodeType.Catch:
+ return AuthorParseNodeKind.apnkCatch;
+ case TypeScript.NodeType.List:
+ return mapList();
+ case TypeScript.NodeType.Script:
+ return AuthorParseNodeKind.apnkProg;
+ case TypeScript.NodeType.ClassDeclaration:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.InterfaceDeclaration:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.ModuleDeclaration:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.ImportDeclaration:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.With:
+ return AuthorParseNodeKind.apnkWith;
+ case TypeScript.NodeType.Label:
+ return AuthorParseNodeKind.apnkLabel;
+ case TypeScript.NodeType.LabeledStatement:
+ return AuthorParseNodeKind.apnkLabel;
+ case TypeScript.NodeType.EBStart:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.GotoEB:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.EndCode:
+ return AuthorParseNodeKind.apnkEndCode;
+ case TypeScript.NodeType.Error:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.Comment:
+ return AuthorParseNodeKind.apnkEmpty;
+ case TypeScript.NodeType.Debugger:
+ return AuthorParseNodeKind.apnkDebugger;
+ default:
+ throw new Error("Invalid node kind: " + nodeType);
+ }
+ };
+ AuthorParseNodeCursor.prototype.mapNodeFlags = function (path) {
+ var result = AuthorParseNodeFlags.apnfNone;
+ if(path.isSynthesizedBlock()) {
+ result = result | AuthorParseNodeFlags.apnfSyntheticNode;
+ }
+ return result;
+ };
+ AuthorParseNodeCursor.prototype.getDetails = function (path) {
+ var ast = path.ast();
+ var result = new AuthorParseNodeDetails();
+ if(path.isListOfObjectLit()) {
+ if(!path.parent().isParenthesized) {
+ Formatting.Debug.Assert(path.parent().minChar == path.ast().minChar, "Assumption about AST minChar position is not verified");
+ Formatting.Debug.Assert(path.parent().limChar == path.ast().limChar, "Assumption about AST limChar position is not verified");
+ }
+ result.StartOffset = ast.minChar + 1;
+ result.EndOffset = ast.limChar - 1;
+ } else {
+ result.StartOffset = ast.minChar;
+ result.EndOffset = ast.limChar;
+ }
+ result.Flags = this.mapNodeFlags(path);
+ result.Kind = this.mapNodeType(path);
+ result.nodeType = ast.nodeType;
+ result.ast = ast;
+ return result;
+ };
+ AuthorParseNodeCursor.prototype.getEdgeLabel = function (path) {
+ if(path.isBodyOfScript() || path.isBodyOfModule() || path.isBodyOfClass() || path.isBodyOfInterface() || path.isBodyOfFunction() || path.isBodyOfFor() || path.isBodyOfForIn() || path.isBodyOfWhile() || path.isBodyOfDoWhile() || path.isBodyOfWith() || path.isBodyOfSwitch() || this.isBodyOfCase(path) || path.isBodyOfTry() || path.isBodyOfCatch() || path.isBodyOfFinally()) {
+ return AuthorParseNodeEdge.apneBody;
+ }
+ if(path.isThenOfIf()) {
+ return AuthorParseNodeEdge.apneThen;
+ }
+ if(path.isElseOfIf()) {
+ return AuthorParseNodeEdge.apneElse;
+ }
+ if(path.isBodyOfBlock() || this.isBodyOfBlock(path)) {
+ return AuthorParseNodeEdge.apneBlockBody;
+ }
+ if(path.isDefaultCaseOfSwitch()) {
+ return AuthorParseNodeEdge.apneDefaultCase;
+ }
+ if(path.isCaseOfSwitch()) {
+ return AuthorParseNodeEdge.apneCase;
+ }
+ if(path.isListOfObjectLit()) {
+ return AuthorParseNodeEdge.apneMembers;
+ }
+ if(path.isListOfArrayLit()) {
+ return AuthorParseNodeEdge.apneElements;
+ }
+ if(path.isMemberOfMember()) {
+ return AuthorParseNodeEdge.apneMember;
+ }
+ if(path.isTargetOfMember()) {
+ return AuthorParseNodeEdge.apneTarget;
+ }
+ if(path.isArgumentOfFunction()) {
+ return AuthorParseNodeEdge.apneArgument;
+ }
+ if(path.isItemOfList()) {
+ return AuthorParseNodeEdge.apneListItem;
+ }
+ return AuthorParseNodeEdge.apneNone;
+ };
+ AuthorParseNodeCursor.prototype.getEmptyNodeDetails = function () {
+ var result = new AuthorParseNodeDetails();
+ result.StartOffset = 0;
+ result.EndOffset = 0;
+ result.Flags = AuthorParseNodeFlags.apnfNone;
+ result.Kind = AuthorParseNodeKind.apnkEmptyNode;
+ result.nodeType = TypeScript.NodeType.Empty;
+ result.ast = null;
+ return result;
+ };
+ AuthorParseNodeCursor.prototype.getAstPath = function (position, options) {
+ if (typeof options === "undefined") { options = TypeScript.GetAstPathOptions.Default; }
+ var path = this.fileAuthoringProxy.scriptSyntaxAST.getAstPathToPosition(position, options);
+ while(path.count() >= 1 && this.skipNode(path)) {
+ path.up();
+ }
+ return path;
+ };
+ AuthorParseNodeCursor.prototype.moveToParent = function (path) {
+ while(path.count() >= 1) {
+ path.up();
+ if(!this.skipNode(path)) {
+ break;
+ }
+ }
+ };
+ AuthorParseNodeCursor.prototype.getAuthorParseNodeDetails = function (path) {
+ if(path.count() === 0) {
+ return this.getEmptyNodeDetails();
+ } else {
+ return this.getDetails(path);
+ }
+ };
+ AuthorParseNodeCursor.prototype.Current = function () {
+ return this.getAuthorParseNodeDetails(this.path);
+ };
+ AuthorParseNodeCursor.prototype.Parent = function () {
+ var temp = this.path.clone();
+ this.moveToParent(temp);
+ return this.getAuthorParseNodeDetails(temp);
+ };
+ AuthorParseNodeCursor.prototype.MoveToChild = function (edgeLabel, index) {
+ var _this = this;
+ var pushIfNotNull = function (node) {
+ if(node != null) {
+ _this.path.push(node);
+ return _this.getAuthorParseNodeDetails(_this.path);
+ } else {
+ return _this.getEmptyNodeDetails();
+ }
+ };
+ if(this.path.count() >= 1) {
+ var ast = this.path.ast();
+ switch(ast.nodeType) {
+ case TypeScript.NodeType.ArrayLit:
+ {
+ switch(edgeLabel) {
+ case AuthorParseNodeEdge.apneElements:
+ return pushIfNotNull((ast).operand);
+ }
+ }
+ break;
+ }
+ }
+ var empty = new TypeScript.AST(TypeScript.NodeType.Empty);
+ this.path.push(empty);
+ return this.getAuthorParseNodeDetails(this.path);
+ };
+ AuthorParseNodeCursor.prototype.MoveUp = function () {
+ this.moveToParent(this.path);
+ return this.getAuthorParseNodeDetails(this.path);
+ };
+ AuthorParseNodeCursor.prototype.SeekToOffset = function (offset, excludeEndOffset) {
+ var newPath = this.getAstPath(offset, excludeEndOffset ? TypeScript.GetAstPathOptions.Default : TypeScript.GetAstPathOptions.EdgeInclusive);
+ this.path = this.fixupPath(newPath);
+ if(this.path.count() == 0) {
+ return null;
+ }
+ return this.getDetails(this.path);
+ };
+ AuthorParseNodeCursor.prototype.MoveToEnclosingNode = function (startOffset, endOffset) {
+ if(startOffset > endOffset) {
+ throw new Error("Invalid offsets");
+ }
+ var start = this.getAstPath(startOffset);
+ var end = this.getAstPath(endOffset - 1);
+ if(start.count() == 0 || end.count() == 0) {
+ throw new Error("No nodes enclosing span");
+ }
+ var startIndex = 0;
+ var endIndex = 0;
+ while(startIndex < start.count() && endIndex < end.count()) {
+ if(start.get(startIndex) !== end.get(endIndex)) {
+ break;
+ }
+ startIndex++;
+ endIndex++;
+ }
+ start.top = startIndex - 1;
+ while(this.skipNode(start)) {
+ start.up();
+ }
+ this.path = this.fixupPath(start);
+ return this.getDetails(this.path);
+ };
+ AuthorParseNodeCursor.prototype.skipNode = function (path) {
+ return path.isBodyOfSwitch() || path.isTopLevelImplicitModule() || path.isBodyOfTopLevelImplicitModule() || (path.isBodyOfBlock() && path.isSingleStatementList()) || (path.isBodyOfCase() && path.isSingleStatementList()) || (path.isArgumentListOfFunction());
+ };
+ AuthorParseNodeCursor.prototype.mapAstNode = function (path, depth) {
+ if(!TypeScript.isValidAstNode(path.ast())) {
+ return null;
+ }
+ if(this.skipNode(path)) {
+ return null;
+ }
+ var result = new AuthorParseNode();
+ result.Details = this.getDetails(path);
+ result.Level = depth;
+ result.Label = 0;
+ result.Name = 0;
+ result.EdgeLabel = this.getEdgeLabel(path);
+ return result;
+ };
+ AuthorParseNodeCursor.prototype.isBodyOfBlock = function (path) {
+ var result = false;
+ if(path.count() >= 2) {
+ if(path.ast().nodeType == TypeScript.NodeType.List && !path.isSingleStatementList() && path.isBodyOfCase()) {
+ result = true;
+ }
+ path.up();
+ if(path.ast().nodeType == TypeScript.NodeType.List && path.isSingleStatementList() && path.isBodyOfCase()) {
+ result = true;
+ }
+ path.down();
+ }
+ return result;
+ };
+ AuthorParseNodeCursor.prototype.isBodyOfCase = function (path) {
+ var asts = path.asts;
+ var top = path.top;
+ return path.count() >= 2 && asts[top - 1].nodeType === TypeScript.NodeType.Case && asts[top - 0].nodeType === TypeScript.NodeType.Block && (asts[top - 1]).body == (asts[top - 0]).statements;
+ };
+ AuthorParseNodeCursor.prototype.mapBodyOfCase = function (body) {
+ var fakeBlock = new TypeScript.Block(body, false);
+ fakeBlock.minChar = body.minChar;
+ fakeBlock.limChar = body.limChar;
+ return fakeBlock;
+ };
+ AuthorParseNodeCursor.prototype.GetSubTree = function (depth) {
+ var _this = this;
+ if(this.path.count() == 0) {
+ return new AuthorParseNodeSet([]);
+ }
+ var context = {
+ path: new TypeScript.AstPath(),
+ nodes: [],
+ curDepth: 0,
+ curDepths: []
+ };
+ var pre = function (cur, parent, walker) {
+ context.curDepths.push(context.curDepth);
+ context.path.push(cur);
+ if(context.path.isBodyOfCase()) {
+ var fakeBlock = _this.mapBodyOfCase(cur);
+ var previousBody = context.path.pop();
+ context.path.push(fakeBlock);
+ context.nodes.push(_this.mapAstNode(context.path, context.curDepth));
+ context.curDepth++;
+ context.path.pop();
+ context.path.push(previousBody);
+ }
+ var node = _this.mapAstNode(context.path, context.curDepth);
+ if(node !== null) {
+ context.nodes.push(node);
+ context.curDepth++;
+ }
+ walker.options.goChildren = (depth < 0 || context.curDepth <= depth);
+ return cur;
+ };
+ var post = function (cur, parent, walker) {
+ context.curDepth = context.curDepths.pop();
+ context.path.pop();
+ return cur;
+ };
+ TypeScript.getAstWalkerFactory().walk(this.path.ast(), pre, post);
+ if(this.logger.information()) {
+ this.logger.log("getSubTree(" + depth + ")");
+ for(var i = 0; i < context.nodes.length; i++) {
+ var authorNode = context.nodes[i];
+ var text = authorNode.Level + ": " + (AuthorParseNodeKind)._map[authorNode.Details.Kind] + " - " + (TypeScript.NodeType)._map[authorNode.Details.nodeType] + "(" + (AuthorParseNodeEdge)._map[authorNode.EdgeLabel] + ")" + "(" + authorNode.Details.StartOffset + "," + authorNode.Details.EndOffset + ")" + " -- F:(" + authorNode.Details.Flags + ")";
+ this.logger.log(text);
+ }
+ }
+ return new AuthorParseNodeSet(context.nodes);
+ };
+ AuthorParseNodeCursor.prototype.GetNodeProperty = function (nodeProperty) {
+ if(this.path.count() == 0) {
+ return 0;
+ }
+ var authorNode = this.mapAstNode(this.path, 0);
+ if(authorNode.Details.ast === null) {
+ return 0;
+ }
+ switch(authorNode.Details.ast.nodeType) {
+ case TypeScript.NodeType.FuncDecl:
+ {
+ var funcDecl = (authorNode.Details.ast);
+ var bod = funcDecl.bod;
+ switch(nodeProperty) {
+ case AuthorParseNodeProperty.apnpFunctionKeywordMin:
+ return funcDecl.minChar;
+ case AuthorParseNodeProperty.apnpLCurlyMin:
+ if(bod !== null && bod.minChar > 0) {
+ return bod.minChar;
+ } else {
+ return 0;
+ }
+ case AuthorParseNodeProperty.apnpRCurlyMin:
+ if(bod !== null && bod.limChar > 0) {
+ return bod.limChar - 1;
+ } else {
+ return 0;
+ }
+ case AuthorParseNodeProperty.apnpRParenMin:
+ if(funcDecl.arguments != null && funcDecl.arguments.limChar > 0) {
+ return funcDecl.arguments.limChar - 1;
+ }
+ }
+ }
+ break;
+ case TypeScript.NodeType.ClassDeclaration:
+ {
+ var classDecl = authorNode.Details.ast;
+ var bod = classDecl.members;
+ switch(nodeProperty) {
+ case AuthorParseNodeProperty.apnpLCurlyMin:
+ if(bod !== null) {
+ return bod.minChar;
+ } else {
+ return 0;
+ }
+ case AuthorParseNodeProperty.apnpRCurlyMin:
+ if(bod !== null) {
+ return bod.limChar - 1;
+ } else {
+ return 0;
+ }
+ }
+ }
+ break;
+ }
+ if(this.logger.warning()) {
+ this.logger.log("NYI:GetNodeProperty " + "(nodeType=" + (TypeScript.NodeType)._map[authorNode.Details.ast.nodeType] + ", " + "propperty= " + (AuthorParseNodeProperty)._map[nodeProperty] + ")");
+ }
+ return 0;
+ };
+ AuthorParseNodeCursor.prototype.GetEdgeLabel = function () {
+ return this.mapAstNode(this.path, 0).EdgeLabel;
+ };
+ return AuthorParseNodeCursor;
+ })();
+ Formatting.AuthorParseNodeCursor = AuthorParseNodeCursor;
+ var TextSnapshot = (function () {
+ function TextSnapshot(script, sourceText) {
+ this.script = script;
+ this.sourceText = sourceText;
+ this.lines = [];
+ }
+ TextSnapshot.prototype.GetText = function (span) {
+ return this.sourceText.getText(span.start(), span.end());
+ };
+ TextSnapshot.prototype.GetLineNumberFromPosition = function (position) {
+ var lineNumber = TypeScript.getLineNumberFromPosition(this.script.locationInfo.lineMap, position);
+ return lineNumber - 1;
+ };
+ TextSnapshot.prototype.GetLineFromPosition = function (position) {
+ var lineNumber = this.GetLineNumberFromPosition(position);
+ return this.GetLineFromLineNumber(lineNumber);
+ };
+ TextSnapshot.prototype.GetLineFromLineNumber = function (lineNumber) {
+ var line = this.lines[lineNumber];
+ if(line === undefined) {
+ line = this.GetLineFromLineNumberWorker(lineNumber);
+ this.lines[lineNumber] = line;
+ }
+ return line;
+ };
+ TextSnapshot.prototype.GetLineFromLineNumberWorker = function (lineNumber) {
+ var lineMap = this.script.locationInfo.lineMap;
+ var lineMapIndex = lineNumber + 1;
+ if(lineMapIndex < 1 || lineMapIndex >= lineMap.length) {
+ throw new Error("invalid line number (" + lineMapIndex + ")");
+ }
+ var start = lineMap[lineMapIndex];
+ var end;
+ var endIncludingLineBreak;
+ var lineBreak = "";
+ if(lineMapIndex == lineMap.length) {
+ end = endIncludingLineBreak = this.sourceText.getLength();
+ } else {
+ endIncludingLineBreak = (lineMapIndex >= lineMap.length - 1 ? this.sourceText.getLength() : this.script.locationInfo.lineMap[lineMapIndex + 1]);
+ for(var p = endIncludingLineBreak - 1; p >= start; p--) {
+ var c = this.sourceText.getText(p, p + 1);
+ if(c != "\r" && c != "\n") {
+ break;
+ }
+ }
+ end = p + 1;
+ lineBreak = this.sourceText.getText(end, endIncludingLineBreak);
+ }
+ var result = new TextSnapshotLine(this, lineNumber, start, end, lineBreak);
+ return result;
+ };
+ return TextSnapshot;
+ })();
+ Formatting.TextSnapshot = TextSnapshot;
+ var TextSnapshotLine = (function () {
+ function TextSnapshotLine(_snapshot, _lineNumber, _start, _end, _lineBreak) {
+ this._snapshot = _snapshot;
+ this._lineNumber = _lineNumber;
+ this._start = _start;
+ this._end = _end;
+ this._lineBreak = _lineBreak;
+ }
+ TextSnapshotLine.prototype.snapshot = function () {
+ return this._snapshot;
+ };
+ TextSnapshotLine.prototype.start = function () {
+ return new SnapshotPoint(this._snapshot, this._start);
+ };
+ TextSnapshotLine.prototype.startPosition = function () {
+ return this._start;
+ };
+ TextSnapshotLine.prototype.end = function () {
+ return new SnapshotPoint(this._snapshot, this._end);
+ };
+ TextSnapshotLine.prototype.endPosition = function () {
+ return this._end;
+ };
+ TextSnapshotLine.prototype.endIncludingLineBreak = function () {
+ return new SnapshotPoint(this._snapshot, this._end + this._lineBreak.length);
+ };
+ TextSnapshotLine.prototype.endIncludingLineBreakPosition = function () {
+ return this._end + this._lineBreak.length;
+ };
+ TextSnapshotLine.prototype.length = function () {
+ return this._end - this._start;
+ };
+ TextSnapshotLine.prototype.lineNumber = function () {
+ return this._lineNumber;
+ };
+ TextSnapshotLine.prototype.getText = function () {
+ return this._snapshot.GetText(Span.FromBounds(this._start, this._end));
+ };
+ return TextSnapshotLine;
+ })();
+ Formatting.TextSnapshotLine = TextSnapshotLine;
+ var Span = (function () {
+ function Span(_start, _length) {
+ this._start = _start;
+ this._length = _length;
+ if(this._start < 0) {
+ throw new Error("Invalid start value");
+ }
+ if(this._length < 0) {
+ throw new Error("Invalid length value");
+ }
+ }
+ Span.prototype.start = function () {
+ return this._start;
+ };
+ Span.prototype.end = function () {
+ return this._start + this._length;
+ };
+ Span.prototype.length = function () {
+ return this._length;
+ };
+ Span.prototype.Intersection = function (span) {
+ var start = Math.Max(this.start(), span.start());
+ var end = Math.Min(this.end(), span.end());
+ if(start <= end) {
+ return Span.FromBounds(start, end);
+ }
+ return null;
+ };
+ Span.prototype.OverlapsWith = function (span) {
+ var num = Math.Max(this.start(), span.start());
+ var num2 = Math.Min(this.end(), span.end());
+ return (num < num2);
+ };
+ Span.prototype.Contains = function (span) {
+ return ((span.start() >= this.start()) && (span.end() <= this.end()));
+ };
+ Span.FromBounds = function FromBounds(start, end) {
+ return new Span(start, end - start);
+ };
+ return Span;
+ })();
+ Formatting.Span = Span;
+ var ListEnumerator = (function () {
+ function ListEnumerator(list) {
+ this.list = list;
+ this.index = -1;
+ }
+ ListEnumerator.prototype.MoveNext = function () {
+ if(this.index < this.list.count() - 1) {
+ this.index++;
+ return true;
+ }
+ return false;
+ };
+ ListEnumerator.prototype.Current = function () {
+ return this.list.get(this.index);
+ };
+ return ListEnumerator;
+ })();
+ Formatting.ListEnumerator = ListEnumerator;
+ var List = (function () {
+ function List() {
+ this.items = List.empty;
+ }
+ List.empty = [];
+ List.prototype.copyOnWrite = function () {
+ if(this.items === List.empty) {
+ this.items = [];
+ }
+ };
+ List.prototype.count = function () {
+ return this.items.length;
+ };
+ List.prototype.get = function (index) {
+ var result = this.items[index];
+ if(result === undefined) {
+ throw new Error("Invalid list index " + index + " (valid range is 0 to " + (this.items.length - 1) + ")");
+ }
+ return result;
+ };
+ List.prototype.add = function (item) {
+ if(item === undefined) {
+ throw new Error("Cannot add an undefined value in a list");
+ }
+ this.copyOnWrite();
+ this.items.push(item);
+ };
+ List.prototype.addAll = function (range) {
+ var _this = this;
+ range.forEach(function (item) {
+ _this.add(item);
+ });
+ };
+ List.prototype.insert = function (index, item) {
+ if(item === undefined) {
+ throw new Error("Cannot add an undefined value in a list");
+ }
+ if(index < 0 || index > this.items.length) {
+ throw new Error("Invalid index when inserting into array" + " (valid range is 0 to " + this.items.length + ")");
+ }
+ this.copyOnWrite();
+ this.items.splice(index, 0, item);
+ };
+ List.prototype.contains = function (item) {
+ var found = false;
+ this.foreach(function (i) {
+ if(i === item) {
+ found = true;
+ }
+ });
+ return found;
+ };
+ List.prototype.foreach = function (action) {
+ var list = this;
+ for(var i = 0, len = list.count(); i < len; i++) {
+ action(list.get(i));
+ }
+ };
+ List.prototype.GetEnumerator = function () {
+ return new ListEnumerator(this);
+ };
+ List.prototype.Where = function (pred) {
+ var result = new List();
+ this.foreach(function (item) {
+ if(pred(item)) {
+ result.add(item);
+ }
+ });
+ return result;
+ };
+ return List;
+ })();
+ Formatting.List = List;
+ var List_TokenSpan = (function (_super) {
+ __extends(List_TokenSpan, _super);
+ function List_TokenSpan() {
+ _super.apply(this, arguments);
+
+ }
+ List_TokenSpan.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_TokenSpan.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_TokenSpan;
+ })(List);
+ Formatting.List_TokenSpan = List_TokenSpan;
+ var List_AuthorTokenKind = (function (_super) {
+ __extends(List_AuthorTokenKind, _super);
+ function List_AuthorTokenKind() {
+ _super.apply(this, arguments);
+
+ }
+ List_AuthorTokenKind.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_AuthorTokenKind.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_AuthorTokenKind;
+ })(List);
+ Formatting.List_AuthorTokenKind = List_AuthorTokenKind;
+ var List_IndentationInfo = (function (_super) {
+ __extends(List_IndentationInfo, _super);
+ function List_IndentationInfo() {
+ _super.apply(this, arguments);
+
+ }
+ List_IndentationInfo.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_IndentationInfo.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_IndentationInfo;
+ })(List);
+ Formatting.List_IndentationInfo = List_IndentationInfo;
+ var List_IndentationEditInfo = (function (_super) {
+ __extends(List_IndentationEditInfo, _super);
+ function List_IndentationEditInfo() {
+ _super.apply(this, arguments);
+
+ }
+ List_IndentationEditInfo.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_IndentationEditInfo.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_IndentationEditInfo;
+ })(List);
+ Formatting.List_IndentationEditInfo = List_IndentationEditInfo;
+ var List_ParseNode = (function (_super) {
+ __extends(List_ParseNode, _super);
+ function List_ParseNode() {
+ _super.apply(this, arguments);
+
+ }
+ List_ParseNode.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_ParseNode.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_ParseNode;
+ })(List);
+ Formatting.List_ParseNode = List_ParseNode;
+ var List_TextEditInfo = (function (_super) {
+ __extends(List_TextEditInfo, _super);
+ function List_TextEditInfo(item) {
+ if (typeof item === "undefined") { item = null; }
+ _super.call(this);
+ if(item != null) {
+ this.add(item);
+ }
+ }
+ List_TextEditInfo.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_TextEditInfo.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_TextEditInfo;
+ })(List);
+ Formatting.List_TextEditInfo = List_TextEditInfo;
+ var List_Rule = (function (_super) {
+ __extends(List_Rule, _super);
+ function List_Rule() {
+ _super.apply(this, arguments);
+
+ }
+ List_Rule.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_Rule.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ List_Rule.prototype.Add = function (item) {
+ _super.prototype.add.call(this, item);
+ };
+ List_Rule.prototype.AddRange = function (items) {
+ var _this = this;
+ items.forEach(function (item) {
+ _this.Add(item);
+ });
+ };
+ return List_Rule;
+ })(List);
+ Formatting.List_Rule = List_Rule;
+ var List_ITextSnapshotLine = (function (_super) {
+ __extends(List_ITextSnapshotLine, _super);
+ function List_ITextSnapshotLine() {
+ _super.apply(this, arguments);
+
+ }
+ List_ITextSnapshotLine.prototype.get = function (index) {
+ return _super.prototype.get.call(this, index);
+ };
+ List_ITextSnapshotLine.prototype.foreach = function (action) {
+ _super.prototype.foreach.call(this, action);
+ };
+ return List_ITextSnapshotLine;
+ })(List);
+ Formatting.List_ITextSnapshotLine = List_ITextSnapshotLine;
+ var Stack = (function () {
+ function Stack() {
+ this.items = [];
+ }
+ Stack.prototype.Count = function () {
+ return this.items.length;
+ };
+ Stack.prototype.Push = function (item) {
+ if(item === undefined) {
+ throw new Error("Cannot add an undefined value in a list");
+ }
+ this.items.push(item);
+ };
+ Stack.prototype.Pop = function () {
+ if(this.items.length === 0) {
+ throw new Error("Cannot pop from an empty stack");
+ }
+ return this.items.pop();
+ };
+ return Stack;
+ })();
+ Formatting.Stack = Stack;
+ var Stack_ParseNode = (function (_super) {
+ __extends(Stack_ParseNode, _super);
+ function Stack_ParseNode() {
+ _super.apply(this, arguments);
+
+ }
+ Stack_ParseNode.prototype.Pop = function () {
+ return _super.prototype.Pop.call(this);
+ };
+ return Stack_ParseNode;
+ })(Stack);
+ Formatting.Stack_ParseNode = Stack_ParseNode;
+ function BinarySearch(list, searchValue, comparer) {
+ var low = 0;
+ var high = list.count();
+ while(low < high) {
+ var median = (low + high) >> 1;
+ var compareResult = comparer(searchValue, list.get(median));
+ if(compareResult > 0) {
+ low = median + 1;
+ } else {
+ high = median;
+ }
+ }
+ Debug.Assert(low >= 0 && low <= list.count(), "Incorrect implementation of BinarySearch");
+ if(low == list.count() || comparer(searchValue, list.get(low)) != 0) {
+ return ~low;
+ }
+ return low;
+ }
+ Formatting.BinarySearch = BinarySearch;
+ function FirstOrDefault(list, pred) {
+ for(var i = 0, len = list.count(); i < len; i++) {
+ if(pred(list.get(i))) {
+ return list.get(i);
+ }
+ }
+ return null;
+ }
+ Formatting.FirstOrDefault = FirstOrDefault;
+ function LastOrDefault(list, pred) {
+ for(var len = list.count(), i = len - 1; i >= 0; i--) {
+ if(pred(list.get(i))) {
+ return list.get(i);
+ }
+ }
+ return null;
+ }
+ Formatting.LastOrDefault = LastOrDefault;
+ var AuthorParseNode = (function () {
+ function AuthorParseNode() {
+ }
+ return AuthorParseNode;
+ })();
+ Formatting.AuthorParseNode = AuthorParseNode;
+ var AuthorParseNodeDetails = (function () {
+ function AuthorParseNodeDetails() {
+ }
+ AuthorParseNodeDetails.prototype.Equals = function (other) {
+ if(other == null) {
+ return false;
+ }
+ return this.Kind == other.Kind && this.nodeType == other.nodeType && this.StartOffset == other.StartOffset && this.EndOffset == other.EndOffset && this.Flags == other.Flags;
+ };
+ return AuthorParseNodeDetails;
+ })();
+ Formatting.AuthorParseNodeDetails = AuthorParseNodeDetails;
+ (function (AuthorParseNodeFlags) {
+ AuthorParseNodeFlags._map = [];
+ AuthorParseNodeFlags.apnfNone = 0x0000;
+ AuthorParseNodeFlags.apnfSyntheticNode = 0x0100;
+ })(Formatting.AuthorParseNodeFlags || (Formatting.AuthorParseNodeFlags = {}));
+ var AuthorParseNodeFlags = Formatting.AuthorParseNodeFlags;
+ (function (AuthorParseNodeKind) {
+ AuthorParseNodeKind._map = [];
+ AuthorParseNodeKind._map[0] = "apnkEmptyNode";
+ AuthorParseNodeKind.apnkEmptyNode = 0;
+ AuthorParseNodeKind._map[1] = "apnkNone";
+ AuthorParseNodeKind.apnkNone = 1;
+ AuthorParseNodeKind._map[2] = "apnkName";
+ AuthorParseNodeKind.apnkName = 2;
+ AuthorParseNodeKind._map[3] = "apnkInt";
+ AuthorParseNodeKind.apnkInt = 3;
+ AuthorParseNodeKind._map[4] = "apnkFlt";
+ AuthorParseNodeKind.apnkFlt = 4;
+ AuthorParseNodeKind._map[5] = "apnkStr";
+ AuthorParseNodeKind.apnkStr = 5;
+ AuthorParseNodeKind._map[6] = "apnkRegExp";
+ AuthorParseNodeKind.apnkRegExp = 6;
+ AuthorParseNodeKind._map[7] = "apnkThis";
+ AuthorParseNodeKind.apnkThis = 7;
+ AuthorParseNodeKind._map[8] = "apnkNull";
+ AuthorParseNodeKind.apnkNull = 8;
+ AuthorParseNodeKind._map[9] = "apnkFalse";
+ AuthorParseNodeKind.apnkFalse = 9;
+ AuthorParseNodeKind._map[10] = "apnkTrue";
+ AuthorParseNodeKind.apnkTrue = 10;
+ AuthorParseNodeKind._map[11] = "apnkEmpty";
+ AuthorParseNodeKind.apnkEmpty = 11;
+ AuthorParseNodeKind._map[12] = "apnkLdFncSlot";
+ AuthorParseNodeKind.apnkLdFncSlot = 12;
+ AuthorParseNodeKind._map[13] = "apnkArgRef";
+ AuthorParseNodeKind.apnkArgRef = 13;
+ AuthorParseNodeKind._map[14] = "apnkHelperCall3";
+ AuthorParseNodeKind.apnkHelperCall3 = 14;
+ AuthorParseNodeKind._map[15] = "apnkNot";
+ AuthorParseNodeKind.apnkNot = 15;
+ AuthorParseNodeKind._map[16] = "apnkNeg";
+ AuthorParseNodeKind.apnkNeg = 16;
+ AuthorParseNodeKind._map[17] = "apnkPos";
+ AuthorParseNodeKind.apnkPos = 17;
+ AuthorParseNodeKind._map[18] = "apnkLogNot";
+ AuthorParseNodeKind.apnkLogNot = 18;
+ AuthorParseNodeKind._map[19] = "apnkIncPost";
+ AuthorParseNodeKind.apnkIncPost = 19;
+ AuthorParseNodeKind._map[20] = "apnkDecPost";
+ AuthorParseNodeKind.apnkDecPost = 20;
+ AuthorParseNodeKind._map[21] = "apnkIncPre";
+ AuthorParseNodeKind.apnkIncPre = 21;
+ AuthorParseNodeKind._map[22] = "apnkDecPre";
+ AuthorParseNodeKind.apnkDecPre = 22;
+ AuthorParseNodeKind._map[23] = "apnkTypeof";
+ AuthorParseNodeKind.apnkTypeof = 23;
+ AuthorParseNodeKind._map[24] = "apnkVoid";
+ AuthorParseNodeKind.apnkVoid = 24;
+ AuthorParseNodeKind._map[25] = "apnkDelete";
+ AuthorParseNodeKind.apnkDelete = 25;
+ AuthorParseNodeKind._map[26] = "apnkArray";
+ AuthorParseNodeKind.apnkArray = 26;
+ AuthorParseNodeKind._map[27] = "apnkObject";
+ AuthorParseNodeKind.apnkObject = 27;
+ AuthorParseNodeKind._map[28] = "apnkTempRef";
+ AuthorParseNodeKind.apnkTempRef = 28;
+ AuthorParseNodeKind._map[29] = "apnkStFncSlot";
+ AuthorParseNodeKind.apnkStFncSlot = 29;
+ AuthorParseNodeKind._map[30] = "apnkAdd";
+ AuthorParseNodeKind.apnkAdd = 30;
+ AuthorParseNodeKind._map[31] = "apnkSub";
+ AuthorParseNodeKind.apnkSub = 31;
+ AuthorParseNodeKind._map[32] = "apnkMul";
+ AuthorParseNodeKind.apnkMul = 32;
+ AuthorParseNodeKind._map[33] = "apnkDiv";
+ AuthorParseNodeKind.apnkDiv = 33;
+ AuthorParseNodeKind._map[34] = "apnkMod";
+ AuthorParseNodeKind.apnkMod = 34;
+ AuthorParseNodeKind._map[35] = "apnkOr";
+ AuthorParseNodeKind.apnkOr = 35;
+ AuthorParseNodeKind._map[36] = "apnkXor";
+ AuthorParseNodeKind.apnkXor = 36;
+ AuthorParseNodeKind._map[37] = "apnkAnd";
+ AuthorParseNodeKind.apnkAnd = 37;
+ AuthorParseNodeKind._map[38] = "apnkEq";
+ AuthorParseNodeKind.apnkEq = 38;
+ AuthorParseNodeKind._map[39] = "apnkNe";
+ AuthorParseNodeKind.apnkNe = 39;
+ AuthorParseNodeKind._map[40] = "apnkLt";
+ AuthorParseNodeKind.apnkLt = 40;
+ AuthorParseNodeKind._map[41] = "apnkLe";
+ AuthorParseNodeKind.apnkLe = 41;
+ AuthorParseNodeKind._map[42] = "apnkGe";
+ AuthorParseNodeKind.apnkGe = 42;
+ AuthorParseNodeKind._map[43] = "apnkGt";
+ AuthorParseNodeKind.apnkGt = 43;
+ AuthorParseNodeKind._map[44] = "apnkCall";
+ AuthorParseNodeKind.apnkCall = 44;
+ AuthorParseNodeKind._map[45] = "apnkDot";
+ AuthorParseNodeKind.apnkDot = 45;
+ AuthorParseNodeKind._map[46] = "apnkAsg";
+ AuthorParseNodeKind.apnkAsg = 46;
+ AuthorParseNodeKind._map[47] = "apnkInstOf";
+ AuthorParseNodeKind.apnkInstOf = 47;
+ AuthorParseNodeKind._map[48] = "apnkIn";
+ AuthorParseNodeKind.apnkIn = 48;
+ AuthorParseNodeKind._map[49] = "apnkEqv";
+ AuthorParseNodeKind.apnkEqv = 49;
+ AuthorParseNodeKind._map[50] = "apnkNEqv";
+ AuthorParseNodeKind.apnkNEqv = 50;
+ AuthorParseNodeKind._map[51] = "apnkComma";
+ AuthorParseNodeKind.apnkComma = 51;
+ AuthorParseNodeKind._map[52] = "apnkLogOr";
+ AuthorParseNodeKind.apnkLogOr = 52;
+ AuthorParseNodeKind._map[53] = "apnkLogAnd";
+ AuthorParseNodeKind.apnkLogAnd = 53;
+ AuthorParseNodeKind._map[54] = "apnkLsh";
+ AuthorParseNodeKind.apnkLsh = 54;
+ AuthorParseNodeKind._map[55] = "apnkRsh";
+ AuthorParseNodeKind.apnkRsh = 55;
+ AuthorParseNodeKind._map[56] = "apnkRs2";
+ AuthorParseNodeKind.apnkRs2 = 56;
+ AuthorParseNodeKind._map[57] = "apnkNew";
+ AuthorParseNodeKind.apnkNew = 57;
+ AuthorParseNodeKind._map[58] = "apnkIndex";
+ AuthorParseNodeKind.apnkIndex = 58;
+ AuthorParseNodeKind._map[59] = "apnkQmark";
+ AuthorParseNodeKind.apnkQmark = 59;
+ AuthorParseNodeKind._map[60] = "apnkAsgAdd";
+ AuthorParseNodeKind.apnkAsgAdd = 60;
+ AuthorParseNodeKind._map[61] = "apnkAsgSub";
+ AuthorParseNodeKind.apnkAsgSub = 61;
+ AuthorParseNodeKind._map[62] = "apnkAsgMul";
+ AuthorParseNodeKind.apnkAsgMul = 62;
+ AuthorParseNodeKind._map[63] = "apnkAsgDiv";
+ AuthorParseNodeKind.apnkAsgDiv = 63;
+ AuthorParseNodeKind._map[64] = "apnkAsgMod";
+ AuthorParseNodeKind.apnkAsgMod = 64;
+ AuthorParseNodeKind._map[65] = "apnkAsgAnd";
+ AuthorParseNodeKind.apnkAsgAnd = 65;
+ AuthorParseNodeKind._map[66] = "apnkAsgXor";
+ AuthorParseNodeKind.apnkAsgXor = 66;
+ AuthorParseNodeKind._map[67] = "apnkAsgOr";
+ AuthorParseNodeKind.apnkAsgOr = 67;
+ AuthorParseNodeKind._map[68] = "apnkAsgLsh";
+ AuthorParseNodeKind.apnkAsgLsh = 68;
+ AuthorParseNodeKind._map[69] = "apnkAsgRsh";
+ AuthorParseNodeKind.apnkAsgRsh = 69;
+ AuthorParseNodeKind._map[70] = "apnkAsgRs2";
+ AuthorParseNodeKind.apnkAsgRs2 = 70;
+ AuthorParseNodeKind._map[71] = "apnkScope";
+ AuthorParseNodeKind.apnkScope = 71;
+ AuthorParseNodeKind._map[72] = "apnkMember";
+ AuthorParseNodeKind.apnkMember = 72;
+ AuthorParseNodeKind._map[73] = "apnkSetMember";
+ AuthorParseNodeKind.apnkSetMember = 73;
+ AuthorParseNodeKind._map[74] = "apnkGetMember";
+ AuthorParseNodeKind.apnkGetMember = 74;
+ AuthorParseNodeKind._map[75] = "apnkList";
+ AuthorParseNodeKind.apnkList = 75;
+ AuthorParseNodeKind._map[76] = "apnkVarDecl";
+ AuthorParseNodeKind.apnkVarDecl = 76;
+ AuthorParseNodeKind._map[77] = "apnkTemp";
+ AuthorParseNodeKind.apnkTemp = 77;
+ AuthorParseNodeKind._map[78] = "apnkFncDecl";
+ AuthorParseNodeKind.apnkFncDecl = 78;
+ AuthorParseNodeKind._map[79] = "apnkProg";
+ AuthorParseNodeKind.apnkProg = 79;
+ AuthorParseNodeKind._map[80] = "apnkEndCode";
+ AuthorParseNodeKind.apnkEndCode = 80;
+ AuthorParseNodeKind._map[81] = "apnkDebugger";
+ AuthorParseNodeKind.apnkDebugger = 81;
+ AuthorParseNodeKind._map[82] = "apnkFor";
+ AuthorParseNodeKind.apnkFor = 82;
+ AuthorParseNodeKind._map[83] = "apnkIf";
+ AuthorParseNodeKind.apnkIf = 83;
+ AuthorParseNodeKind._map[84] = "apnkWhile";
+ AuthorParseNodeKind.apnkWhile = 84;
+ AuthorParseNodeKind._map[85] = "apnkDoWhile";
+ AuthorParseNodeKind.apnkDoWhile = 85;
+ AuthorParseNodeKind._map[86] = "apnkForIn";
+ AuthorParseNodeKind.apnkForIn = 86;
+ AuthorParseNodeKind._map[87] = "apnkBlock";
+ AuthorParseNodeKind.apnkBlock = 87;
+ AuthorParseNodeKind._map[88] = "apnkWith";
+ AuthorParseNodeKind.apnkWith = 88;
+ AuthorParseNodeKind._map[89] = "apnkBreak";
+ AuthorParseNodeKind.apnkBreak = 89;
+ AuthorParseNodeKind._map[90] = "apnkContinue";
+ AuthorParseNodeKind.apnkContinue = 90;
+ AuthorParseNodeKind._map[91] = "apnkLabel";
+ AuthorParseNodeKind.apnkLabel = 91;
+ AuthorParseNodeKind._map[92] = "apnkSwitch";
+ AuthorParseNodeKind.apnkSwitch = 92;
+ AuthorParseNodeKind._map[93] = "apnkCase";
+ AuthorParseNodeKind.apnkCase = 93;
+ AuthorParseNodeKind._map[94] = "apnkTryCatch";
+ AuthorParseNodeKind.apnkTryCatch = 94;
+ AuthorParseNodeKind._map[95] = "apnkCatch";
+ AuthorParseNodeKind.apnkCatch = 95;
+ AuthorParseNodeKind._map[96] = "apnkReturn";
+ AuthorParseNodeKind.apnkReturn = 96;
+ AuthorParseNodeKind._map[97] = "apnkTry";
+ AuthorParseNodeKind.apnkTry = 97;
+ AuthorParseNodeKind._map[98] = "apnkThrow";
+ AuthorParseNodeKind.apnkThrow = 98;
+ AuthorParseNodeKind._map[99] = "apnkFinally";
+ AuthorParseNodeKind.apnkFinally = 99;
+ AuthorParseNodeKind._map[100] = "apnkTryFinally";
+ AuthorParseNodeKind.apnkTryFinally = 100;
+ AuthorParseNodeKind._map[101] = "apnkStruct";
+ AuthorParseNodeKind.apnkStruct = 101;
+ AuthorParseNodeKind._map[102] = "apnkEnum";
+ AuthorParseNodeKind.apnkEnum = 102;
+ AuthorParseNodeKind._map[103] = "apnkTyped";
+ AuthorParseNodeKind.apnkTyped = 103;
+ AuthorParseNodeKind._map[104] = "apnkVarDeclList";
+ AuthorParseNodeKind.apnkVarDeclList = 104;
+ AuthorParseNodeKind._map[105] = "apnkDefaultCase";
+ AuthorParseNodeKind.apnkDefaultCase = 105;
+ })(Formatting.AuthorParseNodeKind || (Formatting.AuthorParseNodeKind = {}));
+ var AuthorParseNodeKind = Formatting.AuthorParseNodeKind;
+ (function (AuthorTokenKind) {
+ AuthorTokenKind._map = [];
+ AuthorTokenKind._map[0] = "atkEnd";
+ AuthorTokenKind.atkEnd = 0;
+ AuthorTokenKind._map[1] = "atkText";
+ AuthorTokenKind.atkText = 1;
+ AuthorTokenKind._map[2] = "atkIdentifier";
+ AuthorTokenKind.atkIdentifier = 2;
+ AuthorTokenKind._map[3] = "atkComment";
+ AuthorTokenKind.atkComment = 3;
+ AuthorTokenKind._map[4] = "atkNumber";
+ AuthorTokenKind.atkNumber = 4;
+ AuthorTokenKind._map[5] = "atkString";
+ AuthorTokenKind.atkString = 5;
+ AuthorTokenKind._map[6] = "atkRegexp";
+ AuthorTokenKind.atkRegexp = 6;
+ AuthorTokenKind._map[7] = "atkConditionalComp";
+ AuthorTokenKind.atkConditionalComp = 7;
+ AuthorTokenKind._map[8] = "atkScanError";
+ AuthorTokenKind.atkScanError = 8;
+ AuthorTokenKind._map[9] = "atkSColon";
+ AuthorTokenKind.atkSColon = 9;
+ AuthorTokenKind._map[10] = "atkLParen";
+ AuthorTokenKind.atkLParen = 10;
+ AuthorTokenKind._map[11] = "atkRParen";
+ AuthorTokenKind.atkRParen = 11;
+ AuthorTokenKind._map[12] = "atkLBrack";
+ AuthorTokenKind.atkLBrack = 12;
+ AuthorTokenKind._map[13] = "atkRBrack";
+ AuthorTokenKind.atkRBrack = 13;
+ AuthorTokenKind._map[14] = "atkLCurly";
+ AuthorTokenKind.atkLCurly = 14;
+ AuthorTokenKind._map[15] = "atkRCurly";
+ AuthorTokenKind.atkRCurly = 15;
+ AuthorTokenKind._map[16] = "atkComma";
+ AuthorTokenKind.atkComma = 16;
+ AuthorTokenKind._map[17] = "atkArrow";
+ AuthorTokenKind.atkArrow = 17;
+ AuthorTokenKind._map[18] = "atkAsg";
+ AuthorTokenKind.atkAsg = 18;
+ AuthorTokenKind._map[19] = "atkAsgAdd";
+ AuthorTokenKind.atkAsgAdd = 19;
+ AuthorTokenKind._map[20] = "atkAsgSub";
+ AuthorTokenKind.atkAsgSub = 20;
+ AuthorTokenKind._map[21] = "atkAsgMul";
+ AuthorTokenKind.atkAsgMul = 21;
+ AuthorTokenKind._map[22] = "atkAsgDiv";
+ AuthorTokenKind.atkAsgDiv = 22;
+ AuthorTokenKind._map[23] = "atkAsgMod";
+ AuthorTokenKind.atkAsgMod = 23;
+ AuthorTokenKind._map[24] = "atkAsgAnd";
+ AuthorTokenKind.atkAsgAnd = 24;
+ AuthorTokenKind._map[25] = "atkAsgXor";
+ AuthorTokenKind.atkAsgXor = 25;
+ AuthorTokenKind._map[26] = "atkAsgOr";
+ AuthorTokenKind.atkAsgOr = 26;
+ AuthorTokenKind._map[27] = "atkAsgLsh";
+ AuthorTokenKind.atkAsgLsh = 27;
+ AuthorTokenKind._map[28] = "atkAsgRsh";
+ AuthorTokenKind.atkAsgRsh = 28;
+ AuthorTokenKind._map[29] = "atkAsgRs2";
+ AuthorTokenKind.atkAsgRs2 = 29;
+ AuthorTokenKind._map[30] = "atkQMark";
+ AuthorTokenKind.atkQMark = 30;
+ AuthorTokenKind._map[31] = "atkColon";
+ AuthorTokenKind.atkColon = 31;
+ AuthorTokenKind._map[32] = "atkLogOr";
+ AuthorTokenKind.atkLogOr = 32;
+ AuthorTokenKind._map[33] = "atkLogAnd";
+ AuthorTokenKind.atkLogAnd = 33;
+ AuthorTokenKind._map[34] = "atkOr";
+ AuthorTokenKind.atkOr = 34;
+ AuthorTokenKind._map[35] = "atkXor";
+ AuthorTokenKind.atkXor = 35;
+ AuthorTokenKind._map[36] = "atkAnd";
+ AuthorTokenKind.atkAnd = 36;
+ AuthorTokenKind._map[37] = "atkEQ";
+ AuthorTokenKind.atkEQ = 37;
+ AuthorTokenKind._map[38] = "atkNE";
+ AuthorTokenKind.atkNE = 38;
+ AuthorTokenKind._map[39] = "atkEqv";
+ AuthorTokenKind.atkEqv = 39;
+ AuthorTokenKind._map[40] = "atkNEqv";
+ AuthorTokenKind.atkNEqv = 40;
+ AuthorTokenKind._map[41] = "atkLT";
+ AuthorTokenKind.atkLT = 41;
+ AuthorTokenKind._map[42] = "atkLE";
+ AuthorTokenKind.atkLE = 42;
+ AuthorTokenKind._map[43] = "atkGT";
+ AuthorTokenKind.atkGT = 43;
+ AuthorTokenKind._map[44] = "atkGE";
+ AuthorTokenKind.atkGE = 44;
+ AuthorTokenKind._map[45] = "atkLsh";
+ AuthorTokenKind.atkLsh = 45;
+ AuthorTokenKind._map[46] = "atkRsh";
+ AuthorTokenKind.atkRsh = 46;
+ AuthorTokenKind._map[47] = "atkRs2";
+ AuthorTokenKind.atkRs2 = 47;
+ AuthorTokenKind._map[48] = "atkAdd";
+ AuthorTokenKind.atkAdd = 48;
+ AuthorTokenKind._map[49] = "atkSub";
+ AuthorTokenKind.atkSub = 49;
+ AuthorTokenKind._map[50] = "atkMult";
+ AuthorTokenKind.atkMult = 50;
+ AuthorTokenKind._map[51] = "atkDiv";
+ AuthorTokenKind.atkDiv = 51;
+ AuthorTokenKind._map[52] = "atkPct";
+ AuthorTokenKind.atkPct = 52;
+ AuthorTokenKind._map[53] = "atkTilde";
+ AuthorTokenKind.atkTilde = 53;
+ AuthorTokenKind._map[54] = "atkBang";
+ AuthorTokenKind.atkBang = 54;
+ AuthorTokenKind._map[55] = "atkInc";
+ AuthorTokenKind.atkInc = 55;
+ AuthorTokenKind._map[56] = "atkDec";
+ AuthorTokenKind.atkDec = 56;
+ AuthorTokenKind._map[57] = "atkDot";
+ AuthorTokenKind.atkDot = 57;
+ AuthorTokenKind._map[58] = "atkScope";
+ AuthorTokenKind.atkScope = 58;
+ AuthorTokenKind._map[59] = "atkEllipsis";
+ AuthorTokenKind.atkEllipsis = 59;
+ AuthorTokenKind._map[60] = "atkBreak";
+ AuthorTokenKind.atkBreak = 60;
+ AuthorTokenKind._map[61] = "atkCase";
+ AuthorTokenKind.atkCase = 61;
+ AuthorTokenKind._map[62] = "atkCatch";
+ AuthorTokenKind.atkCatch = 62;
+ AuthorTokenKind._map[63] = "atkClass";
+ AuthorTokenKind.atkClass = 63;
+ AuthorTokenKind._map[64] = "atkConst";
+ AuthorTokenKind.atkConst = 64;
+ AuthorTokenKind._map[65] = "atkContinue";
+ AuthorTokenKind.atkContinue = 65;
+ AuthorTokenKind._map[66] = "atkDebugger";
+ AuthorTokenKind.atkDebugger = 66;
+ AuthorTokenKind._map[67] = "atkDefault";
+ AuthorTokenKind.atkDefault = 67;
+ AuthorTokenKind._map[68] = "atkDelete";
+ AuthorTokenKind.atkDelete = 68;
+ AuthorTokenKind._map[69] = "atkDo";
+ AuthorTokenKind.atkDo = 69;
+ AuthorTokenKind._map[70] = "atkElse";
+ AuthorTokenKind.atkElse = 70;
+ AuthorTokenKind._map[71] = "atkEnum";
+ AuthorTokenKind.atkEnum = 71;
+ AuthorTokenKind._map[72] = "atkExport";
+ AuthorTokenKind.atkExport = 72;
+ AuthorTokenKind._map[73] = "atkExtends";
+ AuthorTokenKind.atkExtends = 73;
+ AuthorTokenKind._map[74] = "atkFalse";
+ AuthorTokenKind.atkFalse = 74;
+ AuthorTokenKind._map[75] = "atkFinally";
+ AuthorTokenKind.atkFinally = 75;
+ AuthorTokenKind._map[76] = "atkFor";
+ AuthorTokenKind.atkFor = 76;
+ AuthorTokenKind._map[77] = "atkFunction";
+ AuthorTokenKind.atkFunction = 77;
+ AuthorTokenKind._map[78] = "atkIf";
+ AuthorTokenKind.atkIf = 78;
+ AuthorTokenKind._map[79] = "atkImport";
+ AuthorTokenKind.atkImport = 79;
+ AuthorTokenKind._map[80] = "atkIn";
+ AuthorTokenKind.atkIn = 80;
+ AuthorTokenKind._map[81] = "atkInstanceof";
+ AuthorTokenKind.atkInstanceof = 81;
+ AuthorTokenKind._map[82] = "atkNew";
+ AuthorTokenKind.atkNew = 82;
+ AuthorTokenKind._map[83] = "atkNull";
+ AuthorTokenKind.atkNull = 83;
+ AuthorTokenKind._map[84] = "atkReturn";
+ AuthorTokenKind.atkReturn = 84;
+ AuthorTokenKind._map[85] = "atkSuper";
+ AuthorTokenKind.atkSuper = 85;
+ AuthorTokenKind._map[86] = "atkSwitch";
+ AuthorTokenKind.atkSwitch = 86;
+ AuthorTokenKind._map[87] = "atkThis";
+ AuthorTokenKind.atkThis = 87;
+ AuthorTokenKind._map[88] = "atkThrow";
+ AuthorTokenKind.atkThrow = 88;
+ AuthorTokenKind._map[89] = "atkTrue";
+ AuthorTokenKind.atkTrue = 89;
+ AuthorTokenKind._map[90] = "atkTry";
+ AuthorTokenKind.atkTry = 90;
+ AuthorTokenKind._map[91] = "atkTypeof";
+ AuthorTokenKind.atkTypeof = 91;
+ AuthorTokenKind._map[92] = "atkVar";
+ AuthorTokenKind.atkVar = 92;
+ AuthorTokenKind._map[93] = "atkVoid";
+ AuthorTokenKind.atkVoid = 93;
+ AuthorTokenKind._map[94] = "atkWhile";
+ AuthorTokenKind.atkWhile = 94;
+ AuthorTokenKind._map[95] = "atkWith";
+ AuthorTokenKind.atkWith = 95;
+ AuthorTokenKind._map[96] = "atkConstructor";
+ AuthorTokenKind.atkConstructor = 96;
+ AuthorTokenKind._map[97] = "atkDeclare";
+ AuthorTokenKind.atkDeclare = 97;
+ AuthorTokenKind._map[98] = "atkModule";
+ AuthorTokenKind.atkModule = 98;
+ AuthorTokenKind._map[99] = "atkGet";
+ AuthorTokenKind.atkGet = 99;
+ AuthorTokenKind._map[100] = "atkSet";
+ AuthorTokenKind.atkSet = 100;
+ AuthorTokenKind._map[101] = "atkImplements";
+ AuthorTokenKind.atkImplements = 101;
+ AuthorTokenKind._map[102] = "atkInterface";
+ AuthorTokenKind.atkInterface = 102;
+ AuthorTokenKind._map[103] = "atkLet";
+ AuthorTokenKind.atkLet = 103;
+ AuthorTokenKind._map[104] = "atkPackage";
+ AuthorTokenKind.atkPackage = 104;
+ AuthorTokenKind._map[105] = "atkPrivate";
+ AuthorTokenKind.atkPrivate = 105;
+ AuthorTokenKind._map[106] = "atkProtected";
+ AuthorTokenKind.atkProtected = 106;
+ AuthorTokenKind._map[107] = "atkPublic";
+ AuthorTokenKind.atkPublic = 107;
+ AuthorTokenKind._map[108] = "atkStatic";
+ AuthorTokenKind.atkStatic = 108;
+ AuthorTokenKind._map[109] = "atkYield";
+ AuthorTokenKind.atkYield = 109;
+ AuthorTokenKind._map[110] = "Length";
+ AuthorTokenKind.Length = 110;
+ })(Formatting.AuthorTokenKind || (Formatting.AuthorTokenKind = {}));
+ var AuthorTokenKind = Formatting.AuthorTokenKind;
+ (function (AuthorParseNodeEdge) {
+ AuthorParseNodeEdge._map = [];
+ AuthorParseNodeEdge._map[0] = "apneNone";
+ AuthorParseNodeEdge.apneNone = 0;
+ AuthorParseNodeEdge._map[1] = "apneOperand";
+ AuthorParseNodeEdge.apneOperand = 1;
+ AuthorParseNodeEdge._map[2] = "apneLeft";
+ AuthorParseNodeEdge.apneLeft = 2;
+ AuthorParseNodeEdge._map[3] = "apneRight";
+ AuthorParseNodeEdge.apneRight = 3;
+ AuthorParseNodeEdge._map[4] = "apneCondition";
+ AuthorParseNodeEdge.apneCondition = 4;
+ AuthorParseNodeEdge._map[5] = "apneThen";
+ AuthorParseNodeEdge.apneThen = 5;
+ AuthorParseNodeEdge._map[6] = "apneElse";
+ AuthorParseNodeEdge.apneElse = 6;
+ AuthorParseNodeEdge._map[7] = "apneInitialization";
+ AuthorParseNodeEdge.apneInitialization = 7;
+ AuthorParseNodeEdge._map[8] = "apneIncrement";
+ AuthorParseNodeEdge.apneIncrement = 8;
+ AuthorParseNodeEdge._map[9] = "apneBody";
+ AuthorParseNodeEdge.apneBody = 9;
+ AuthorParseNodeEdge._map[10] = "apneBlockBody";
+ AuthorParseNodeEdge.apneBlockBody = 10;
+ AuthorParseNodeEdge._map[11] = "apneValue";
+ AuthorParseNodeEdge.apneValue = 11;
+ AuthorParseNodeEdge._map[12] = "apneTarget";
+ AuthorParseNodeEdge.apneTarget = 12;
+ AuthorParseNodeEdge._map[13] = "apneArgument";
+ AuthorParseNodeEdge.apneArgument = 13;
+ AuthorParseNodeEdge._map[14] = "apneArguments";
+ AuthorParseNodeEdge.apneArguments = 14;
+ AuthorParseNodeEdge._map[15] = "apneMembers";
+ AuthorParseNodeEdge.apneMembers = 15;
+ AuthorParseNodeEdge._map[16] = "apneVariable";
+ AuthorParseNodeEdge.apneVariable = 16;
+ AuthorParseNodeEdge._map[17] = "apneObject";
+ AuthorParseNodeEdge.apneObject = 17;
+ AuthorParseNodeEdge._map[18] = "apneTry";
+ AuthorParseNodeEdge.apneTry = 18;
+ AuthorParseNodeEdge._map[19] = "apneCatch";
+ AuthorParseNodeEdge.apneCatch = 19;
+ AuthorParseNodeEdge._map[20] = "apneFinally";
+ AuthorParseNodeEdge.apneFinally = 20;
+ AuthorParseNodeEdge._map[21] = "apneCase";
+ AuthorParseNodeEdge.apneCase = 21;
+ AuthorParseNodeEdge._map[22] = "apneDefaultCase";
+ AuthorParseNodeEdge.apneDefaultCase = 22;
+ AuthorParseNodeEdge._map[23] = "apneElements";
+ AuthorParseNodeEdge.apneElements = 23;
+ AuthorParseNodeEdge._map[24] = "apneListItem";
+ AuthorParseNodeEdge.apneListItem = 24;
+ AuthorParseNodeEdge._map[25] = "apneMember";
+ AuthorParseNodeEdge.apneMember = 25;
+ AuthorParseNodeEdge._map[26] = "apneType";
+ AuthorParseNodeEdge.apneType = 26;
+ })(Formatting.AuthorParseNodeEdge || (Formatting.AuthorParseNodeEdge = {}));
+ var AuthorParseNodeEdge = Formatting.AuthorParseNodeEdge;
+ var AuthorParseNodeSet = (function () {
+ function AuthorParseNodeSet(nodes) {
+ this.nodes = nodes;
+ }
+ AuthorParseNodeSet.prototype.Count = function () {
+ return this.nodes.length;
+ };
+ AuthorParseNodeSet.prototype.GetItems = function (startIndex, count) {
+ if(startIndex == 0 && count == this.nodes.length) {
+ return this.nodes;
+ }
+ throw new Error("Invalid call to GetItems");
+ };
+ return AuthorParseNodeSet;
+ })();
+ Formatting.AuthorParseNodeSet = AuthorParseNodeSet;
+ (function (AuthorParseNodeProperty) {
+ AuthorParseNodeProperty._map = [];
+ AuthorParseNodeProperty._map[0] = "apnpLCurlyMin";
+ AuthorParseNodeProperty.apnpLCurlyMin = 0;
+ AuthorParseNodeProperty._map[1] = "apnpRCurlyMin";
+ AuthorParseNodeProperty.apnpRCurlyMin = 1;
+ AuthorParseNodeProperty._map[2] = "apnpLParenMin";
+ AuthorParseNodeProperty.apnpLParenMin = 2;
+ AuthorParseNodeProperty._map[3] = "apnpRParenMin";
+ AuthorParseNodeProperty.apnpRParenMin = 3;
+ AuthorParseNodeProperty._map[4] = "apnpLBrackMin";
+ AuthorParseNodeProperty.apnpLBrackMin = 4;
+ AuthorParseNodeProperty._map[5] = "apnpRBrackMin";
+ AuthorParseNodeProperty.apnpRBrackMin = 5;
+ AuthorParseNodeProperty._map[6] = "apnpIdentifierMin";
+ AuthorParseNodeProperty.apnpIdentifierMin = 6;
+ AuthorParseNodeProperty._map[7] = "apnpFunctionKeywordMin";
+ AuthorParseNodeProperty.apnpFunctionKeywordMin = 7;
+ })(Formatting.AuthorParseNodeProperty || (Formatting.AuthorParseNodeProperty = {}));
+ var AuthorParseNodeProperty = Formatting.AuthorParseNodeProperty;
+ var AuthorTokenKindMap = (function () {
+ function AuthorTokenKindMap() {
+ this.tokenMap = [];
+ this.init();
+ }
+ AuthorTokenKindMap.instance = null;
+ AuthorTokenKindMap.getInstance = function getInstance() {
+ if(AuthorTokenKindMap.instance === null) {
+ AuthorTokenKindMap.instance = new AuthorTokenKindMap();
+ }
+ return AuthorTokenKindMap.instance;
+ };
+ AuthorTokenKindMap.prototype.init = function () {
+ for(var i = 0, len = TypeScript.TokenID.Lim; i < len; i++) {
+ this.tokenMap[i] = this.mapTokenID(i);
+ }
+ };
+ AuthorTokenKindMap.prototype.getTokenKind = function (kind) {
+ return this.tokenMap[kind];
+ };
+ AuthorTokenKindMap.prototype.mapTokenID = function (kind) {
+ switch(kind) {
+ case TypeScript.TokenID.Any:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.Bool:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.Break:
+ return AuthorTokenKind.atkBreak;
+ case TypeScript.TokenID.Case:
+ return AuthorTokenKind.atkCase;
+ case TypeScript.TokenID.Catch:
+ return AuthorTokenKind.atkCatch;
+ case TypeScript.TokenID.Class:
+ return AuthorTokenKind.atkClass;
+ case TypeScript.TokenID.Const:
+ return AuthorTokenKind.atkConst;
+ case TypeScript.TokenID.Continue:
+ return AuthorTokenKind.atkContinue;
+ case TypeScript.TokenID.Debugger:
+ return AuthorTokenKind.atkDebugger;
+ case TypeScript.TokenID.Default:
+ return AuthorTokenKind.atkDefault;
+ case TypeScript.TokenID.Delete:
+ return AuthorTokenKind.atkDelete;
+ case TypeScript.TokenID.Do:
+ return AuthorTokenKind.atkDo;
+ case TypeScript.TokenID.Else:
+ return AuthorTokenKind.atkElse;
+ case TypeScript.TokenID.Enum:
+ return AuthorTokenKind.atkEnum;
+ case TypeScript.TokenID.Export:
+ return AuthorTokenKind.atkExport;
+ case TypeScript.TokenID.Extends:
+ return AuthorTokenKind.atkExtends;
+ case TypeScript.TokenID.Declare:
+ return AuthorTokenKind.atkDeclare;
+ case TypeScript.TokenID.False:
+ return AuthorTokenKind.atkFalse;
+ case TypeScript.TokenID.Finally:
+ return AuthorTokenKind.atkFinally;
+ case TypeScript.TokenID.For:
+ return AuthorTokenKind.atkFor;
+ case TypeScript.TokenID.Constructor:
+ return AuthorTokenKind.atkConstructor;
+ case TypeScript.TokenID.Function:
+ return AuthorTokenKind.atkFunction;
+ case TypeScript.TokenID.Get:
+ return AuthorTokenKind.atkGet;
+ case TypeScript.TokenID.If:
+ return AuthorTokenKind.atkIf;
+ case TypeScript.TokenID.Implements:
+ return AuthorTokenKind.atkImplements;
+ case TypeScript.TokenID.Import:
+ return AuthorTokenKind.atkImport;
+ case TypeScript.TokenID.In:
+ return AuthorTokenKind.atkIn;
+ case TypeScript.TokenID.InstanceOf:
+ return AuthorTokenKind.atkInstanceof;
+ case TypeScript.TokenID.Interface:
+ return AuthorTokenKind.atkInterface;
+ case TypeScript.TokenID.Let:
+ return AuthorTokenKind.atkLet;
+ case TypeScript.TokenID.Module:
+ return AuthorTokenKind.atkModule;
+ case TypeScript.TokenID.New:
+ return AuthorTokenKind.atkNew;
+ case TypeScript.TokenID.Number:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.Null:
+ return AuthorTokenKind.atkNull;
+ case TypeScript.TokenID.Package:
+ return AuthorTokenKind.atkPackage;
+ case TypeScript.TokenID.Private:
+ return AuthorTokenKind.atkPrivate;
+ case TypeScript.TokenID.Protected:
+ return AuthorTokenKind.atkProtected;
+ case TypeScript.TokenID.Public:
+ return AuthorTokenKind.atkPublic;
+ case TypeScript.TokenID.With:
+ return AuthorTokenKind.atkWith;
+ case TypeScript.TokenID.Return:
+ return AuthorTokenKind.atkReturn;
+ case TypeScript.TokenID.Set:
+ return AuthorTokenKind.atkSet;
+ case TypeScript.TokenID.Static:
+ return AuthorTokenKind.atkStatic;
+ case TypeScript.TokenID.String:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.Super:
+ return AuthorTokenKind.atkSuper;
+ case TypeScript.TokenID.Switch:
+ return AuthorTokenKind.atkSwitch;
+ case TypeScript.TokenID.This:
+ return AuthorTokenKind.atkThis;
+ case TypeScript.TokenID.Throw:
+ return AuthorTokenKind.atkThrow;
+ case TypeScript.TokenID.True:
+ return AuthorTokenKind.atkTrue;
+ case TypeScript.TokenID.Try:
+ return AuthorTokenKind.atkTry;
+ case TypeScript.TokenID.TypeOf:
+ return AuthorTokenKind.atkTypeof;
+ case TypeScript.TokenID.Var:
+ return AuthorTokenKind.atkVar;
+ case TypeScript.TokenID.Void:
+ return AuthorTokenKind.atkVoid;
+ case TypeScript.TokenID.While:
+ return AuthorTokenKind.atkWhile;
+ case TypeScript.TokenID.Yield:
+ return AuthorTokenKind.atkYield;
+ case TypeScript.TokenID.Semicolon:
+ return AuthorTokenKind.atkSColon;
+ case TypeScript.TokenID.OpenParen:
+ return AuthorTokenKind.atkLParen;
+ case TypeScript.TokenID.CloseParen:
+ return AuthorTokenKind.atkRParen;
+ case TypeScript.TokenID.OpenBracket:
+ return AuthorTokenKind.atkLBrack;
+ case TypeScript.TokenID.CloseBracket:
+ return AuthorTokenKind.atkRBrack;
+ case TypeScript.TokenID.OpenBrace:
+ return AuthorTokenKind.atkLCurly;
+ case TypeScript.TokenID.CloseBrace:
+ return AuthorTokenKind.atkRCurly;
+ case TypeScript.TokenID.Comma:
+ return AuthorTokenKind.atkComma;
+ case TypeScript.TokenID.Equals:
+ return AuthorTokenKind.atkAsg;
+ case TypeScript.TokenID.PlusEquals:
+ return AuthorTokenKind.atkAsgAdd;
+ case TypeScript.TokenID.MinusEquals:
+ return AuthorTokenKind.atkAsgSub;
+ case TypeScript.TokenID.AsteriskEquals:
+ return AuthorTokenKind.atkAsgMul;
+ case TypeScript.TokenID.SlashEquals:
+ return AuthorTokenKind.atkAsgDiv;
+ case TypeScript.TokenID.PercentEquals:
+ return AuthorTokenKind.atkAsgMod;
+ case TypeScript.TokenID.AmpersandEquals:
+ return AuthorTokenKind.atkAsgAnd;
+ case TypeScript.TokenID.CaretEquals:
+ return AuthorTokenKind.atkAsgXor;
+ case TypeScript.TokenID.BarEquals:
+ return AuthorTokenKind.atkAsgOr;
+ case TypeScript.TokenID.LessThanLessThanEquals:
+ return AuthorTokenKind.atkAsgLsh;
+ case TypeScript.TokenID.GreaterThanGreaterThanEquals:
+ return AuthorTokenKind.atkAsgRsh;
+ case TypeScript.TokenID.GreaterThanGreaterThanGreaterThanEquals:
+ return AuthorTokenKind.atkAsgRs2;
+ case TypeScript.TokenID.Question:
+ return AuthorTokenKind.atkQMark;
+ case TypeScript.TokenID.Colon:
+ return AuthorTokenKind.atkColon;
+ case TypeScript.TokenID.BarBar:
+ return AuthorTokenKind.atkLogOr;
+ case TypeScript.TokenID.AmpersandAmpersand:
+ return AuthorTokenKind.atkLogAnd;
+ case TypeScript.TokenID.Bar:
+ return AuthorTokenKind.atkOr;
+ case TypeScript.TokenID.Caret:
+ return AuthorTokenKind.atkXor;
+ case TypeScript.TokenID.And:
+ return AuthorTokenKind.atkAnd;
+ case TypeScript.TokenID.EqualsEquals:
+ return AuthorTokenKind.atkEQ;
+ case TypeScript.TokenID.ExclamationEquals:
+ return AuthorTokenKind.atkNE;
+ case TypeScript.TokenID.EqualsEqualsEquals:
+ return AuthorTokenKind.atkEqv;
+ case TypeScript.TokenID.ExclamationEqualsEquals:
+ return AuthorTokenKind.atkNEqv;
+ case TypeScript.TokenID.LessThan:
+ return AuthorTokenKind.atkLT;
+ case TypeScript.TokenID.LessThanEquals:
+ return AuthorTokenKind.atkLE;
+ case TypeScript.TokenID.GreaterThan:
+ return AuthorTokenKind.atkGT;
+ case TypeScript.TokenID.GreaterThanEquals:
+ return AuthorTokenKind.atkGE;
+ case TypeScript.TokenID.LessThanLessThan:
+ return AuthorTokenKind.atkLsh;
+ case TypeScript.TokenID.GreaterThanGreaterThan:
+ return AuthorTokenKind.atkRsh;
+ case TypeScript.TokenID.GreaterThanGreaterThanGreaterThan:
+ return AuthorTokenKind.atkRs2;
+ case TypeScript.TokenID.Plus:
+ return AuthorTokenKind.atkAdd;
+ case TypeScript.TokenID.Minus:
+ return AuthorTokenKind.atkSub;
+ case TypeScript.TokenID.Asterisk:
+ return AuthorTokenKind.atkMult;
+ case TypeScript.TokenID.Slash:
+ return AuthorTokenKind.atkDiv;
+ case TypeScript.TokenID.Percent:
+ return AuthorTokenKind.atkPct;
+ case TypeScript.TokenID.Tilde:
+ return AuthorTokenKind.atkTilde;
+ case TypeScript.TokenID.Exclamation:
+ return AuthorTokenKind.atkBang;
+ case TypeScript.TokenID.PlusPlus:
+ return AuthorTokenKind.atkInc;
+ case TypeScript.TokenID.MinusMinus:
+ return AuthorTokenKind.atkDec;
+ case TypeScript.TokenID.Dot:
+ return AuthorTokenKind.atkDot;
+ case TypeScript.TokenID.DotDotDot:
+ return AuthorTokenKind.atkEllipsis;
+ case TypeScript.TokenID.Error:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.EndOfFile:
+ return AuthorTokenKind.atkEnd;
+ case TypeScript.TokenID.EqualsGreaterThan:
+ return AuthorTokenKind.atkArrow;
+ case TypeScript.TokenID.Identifier:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.StringLiteral:
+ return AuthorTokenKind.atkString;
+ case TypeScript.TokenID.RegularExpressionLiteral:
+ return AuthorTokenKind.atkRegexp;
+ case TypeScript.TokenID.NumberLiteral:
+ return AuthorTokenKind.atkNumber;
+ case TypeScript.TokenID.Whitespace:
+ return AuthorTokenKind.atkIdentifier;
+ case TypeScript.TokenID.Comment:
+ return AuthorTokenKind.atkComment;
+ default:
+ throw new Error("Invalid token kind:" + kind + " (" + (TypeScript.TokenID)._map[kind] + ")");
+ }
+ };
+ return AuthorTokenKindMap;
+ })();
+ Formatting.AuthorTokenKindMap = AuthorTokenKindMap;
+ var Debug = (function () {
+ function Debug() { }
+ Debug.Assert = function Assert(cond, msg) {
+ if(!cond) {
+ throw new Error("assertion failure: " + msg);
+ }
+ };
+ Debug.Fail = function Fail(msg) {
+ Debug.Assert(false, msg);
+ };
+ return Debug;
+ })();
+ Formatting.Debug = Debug;
+ var HashSet_int = (function () {
+ function HashSet_int() {
+ this.items = [];
+ }
+ HashSet_int.prototype.Contains = function (item) {
+ return this.items[item] !== undefined;
+ };
+ HashSet_int.prototype.Add = function (item) {
+ this.items[item] = item;
+ };
+ return HashSet_int;
+ })();
+ Formatting.HashSet_int = HashSet_int;
+ var Dictionary_int_List_IndentationEditInfo = (function () {
+ function Dictionary_int_List_IndentationEditInfo() {
+ this.items = [];
+ }
+ Dictionary_int_List_IndentationEditInfo.prototype.GetValue = function (key) {
+ var result = this.items[key];
+ return result === undefined ? null : result;
+ };
+ Dictionary_int_List_IndentationEditInfo.prototype.Add = function (key, value) {
+ this.items[key] = value;
+ };
+ return Dictionary_int_List_IndentationEditInfo;
+ })();
+ Formatting.Dictionary_int_List_IndentationEditInfo = Dictionary_int_List_IndentationEditInfo;
+ var Dictionary_int_int = (function () {
+ function Dictionary_int_int() {
+ this.items = [];
+ }
+ Dictionary_int_int.prototype.GetValue = function (key) {
+ var result = this.items[key];
+ return result === undefined ? null : result;
+ };
+ Dictionary_int_int.prototype.Add = function (key, value) {
+ this.items[key] = value;
+ };
+ return Dictionary_int_int;
+ })();
+ Formatting.Dictionary_int_int = Dictionary_int_int;
+ var Math = (function () {
+ function Math() { }
+ Math.Max = function Max(x, y) {
+ return (x > y ? x : y);
+ };
+ Math.Min = function Min(x, y) {
+ return (x < y ? x : y);
+ };
+ return Math;
+ })();
+ Formatting.Math = Math;
+ var StringUtils = (function () {
+ function StringUtils() { }
+ StringUtils.IndexOf = function IndexOf(value, search, startIndex) {
+ if (typeof startIndex === "undefined") { startIndex = 0; }
+ return value.indexOf(search, startIndex);
+ };
+ StringUtils.Equals = function Equals(x, y) {
+ return x == y;
+ };
+ StringUtils.IsNullOrEmpty = function IsNullOrEmpty(x) {
+ return x === null || x === "";
+ };
+ StringUtils.IsWhiteSpace = function IsWhiteSpace(charCode) {
+ return EditorUtilities.IsWhitespace(charCode);
+ };
+ StringUtils.create = function create(value, count) {
+ var result = "";
+ for(var i = 0; i < count; i++) {
+ result += value;
+ }
+ return result;
+ };
+ StringUtils.foreach = function foreach(x, action) {
+ for(var i = 0; i < x.length; i++) {
+ action(x.charAt(i));
+ }
+ };
+ return StringUtils;
+ })();
+ Formatting.StringUtils = StringUtils;
+ var EditorUtilities = (function () {
+ function EditorUtilities() { }
+ EditorUtilities.IsWhitespace = function IsWhitespace(charCode) {
+ switch(charCode) {
+ case 0x0009:
+ case 0x000b:
+ case 0x000c:
+ case 0xfeff:
+ case 0x0020:
+ case 0x00a0:
+ case 0x1680:
+ case 0x2000:
+ case 0x2001:
+ case 0x2002:
+ case 0x2003:
+ case 0x2004:
+ case 0x2005:
+ case 0x2006:
+ case 0x2007:
+ case 0x2008:
+ case 0x2009:
+ case 0x200a:
+ case 0x202f:
+ case 0x200b:
+ case 0x3000:
+ case 0x180e:
+ case 0x205f:
+ return true;
+ default:
+ return false;
+ }
+ };
+ return EditorUtilities;
+ })();
+ Formatting.EditorUtilities = EditorUtilities;
+ function getTokensInSpan(logger, scriptSyntaxAST, tokenKindMap, span) {
+ var tokens = new List_TokenSpan();
+ var tokenStream = scriptSyntaxAST.getTokenStream(span.startPosition());
+ while(tokenStream.moveNext()) {
+ if(logger.information()) {
+ var text = "token: " + (TypeScript.TokenID)._map[tokenStream.tokenId()] + " - startPos=" + tokenStream.tokenStartPos() + ", pos=" + tokenStream.tokenEndPos();
+ logger.log(text);
+ }
+ var endPos = tokenStream.tokenEndPos();
+ if(endPos < span.startPosition()) {
+ continue;
+ }
+ var startPos = tokenStream.tokenStartPos();
+ if(startPos > span.endPosition()) {
+ break;
+ }
+ var kind = tokenKindMap.getTokenKind(tokenStream.tokenId());
+ var tokenSpan = new Formatting.TokenSpan(kind, tokenStream.tokenId(), new SnapshotSpan(span.snapshot, Span.FromBounds(startPos, endPos)));
+ tokens.add(tokenSpan);
+ }
+ logger.log("GetTokens([" + span.startPosition() + "," + span.endPosition() + "]): returned " + tokens.count() + " tokens from source text offset " + tokenStream.sourceTextOffset());
+ return tokens;
+ }
+ Formatting.getTokensInSpan = getTokensInSpan;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var FormattingContext = (function () {
+ function FormattingContext(fileAuthoringProxy, snapshot, tokens, formattingRequestKind) {
+ this.fileAuthoringProxy = fileAuthoringProxy;
+ this.snapshot = snapshot;
+ this.tokens = tokens;
+ this.formattingRequestKind = formattingRequestKind;
+ this.contextNode = null;
+ this.tokenSpan = null;
+ this.nextTokenSpan = null;
+ this.contextNodeAllOnSameLine = undefined;
+ this.tokensAreOnSameLine = undefined;
+ this.tokensAreSiblingNodesOnSameLine = undefined;
+ Formatting.Debug.Assert(this.snapshot != null, "snapshot is null");
+ Formatting.Debug.Assert(this.tokens != null, "tokens is null");
+ }
+ FormattingContext.prototype.findTokenAtPosition = function (position) {
+ var index = Formatting.BinarySearch(this.tokens, position, function (position, tokenSpan) {
+ if(position < tokenSpan.Span.startPosition()) {
+ return -1;
+ } else if(position < tokenSpan.Span.endPosition()) {
+ return 0;
+ } else {
+ return 1;
+ }
+ });
+ if(index < 0) {
+ return null;
+ } else {
+ return this.tokens.get(index);
+ }
+ };
+ FormattingContext.prototype.setContext = function (node, t1, t2) {
+ Formatting.Debug.Assert(node != null, "node is null");
+ Formatting.Debug.Assert(t1 != null, "t1 is null");
+ Formatting.Debug.Assert(t2 != null, "t2 is null");
+ this.contextNode = node;
+ this.tokenSpan = t1;
+ this.nextTokenSpan = t2;
+ this.contextNodeAllOnSameLine = undefined;
+ this.tokensAreOnSameLine = undefined;
+ this.tokensAreSiblingNodesOnSameLine = undefined;
+ };
+ FormattingContext.prototype.ContextNodeAllOnSameLine = function () {
+ if(this.contextNodeAllOnSameLine === undefined) {
+ var blockSpan = this.contextNode.GetBlockSpan(this.fileAuthoringProxy, this.tokens);
+ var openToken = this.findTokenAtPosition(blockSpan.start());
+ if(openToken != null && openToken.tokenID == TypeScript.TokenID.OpenBrace) {
+ var closeToken = this.findTokenAtPosition(blockSpan.end() - 1);
+ if(closeToken == null || closeToken.tokenID != TypeScript.TokenID.CloseBrace) {
+ for(var position = blockSpan.end() - 2; position > openToken.Span.endPosition(); position--) {
+ closeToken = this.findTokenAtPosition(position);
+ if(closeToken != null) {
+ blockSpan = Formatting.Span.FromBounds(openToken.Span.startPosition(), closeToken.Span.endPosition());
+ break;
+ }
+ }
+ }
+ }
+ var startLine = this.snapshot.GetLineNumberFromPosition(blockSpan.start());
+ var endLine = this.snapshot.GetLineNumberFromPosition(blockSpan.end());
+ this.contextNodeAllOnSameLine = (startLine == endLine);
+ }
+ return this.contextNodeAllOnSameLine;
+ };
+ FormattingContext.prototype.TokensAreOnSameLine = function () {
+ if(this.tokensAreOnSameLine === undefined) {
+ var startLine = this.tokenSpan.lineNumber();
+ var endLine = this.nextTokenSpan.lineNumber();
+ this.tokensAreOnSameLine = (startLine == endLine);
+ }
+ return this.tokensAreOnSameLine;
+ };
+ FormattingContext.prototype.TokensAreSiblingNodesOnSameLine = function () {
+ if(this.tokensAreSiblingNodesOnSameLine === undefined) {
+ this.tokensAreSiblingNodesOnSameLine = this.AreTokensSiblingNodesOnSameLine();
+ }
+ return this.tokensAreSiblingNodesOnSameLine;
+ };
+ FormattingContext.prototype.AreTokensSiblingNodesOnSameLine = function () {
+ if(this.contextNode.children() == null || this.contextNode.children().count() < 2) {
+ return false;
+ }
+ var current = null;
+ var sibling = null;
+ var nodeIndex = Formatting.ParseNodeExtensions.TryFindNodeIndexForStartOffset(this.contextNode.children(), this.nextTokenSpan.Span.startPosition());
+ if(nodeIndex < 0) {
+ return false;
+ }
+ sibling = this.contextNode.children().get(nodeIndex);
+ for(var i = nodeIndex - 1; i >= 0; --i) {
+ var child = this.contextNode.children().get(i);
+ if(child.AuthorNode.Details.EndOffset == this.tokenSpan.Span.endPosition()) {
+ current = child;
+ break;
+ }
+ }
+ if(current == null) {
+ return false;
+ }
+ var startLine = this.snapshot.GetLineNumberFromPosition(current.AuthorNode.Details.EndOffset);
+ var endLine = this.snapshot.GetLineNumberFromPosition(sibling.AuthorNode.Details.StartOffset);
+ return startLine == endLine;
+ };
+ return FormattingContext;
+ })();
+ Formatting.FormattingContext = FormattingContext;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var FormattingManager = (function () {
+ function FormattingManager(scriptSyntaxAST, rulesProvider, editorOptions) {
+ this.scriptSyntaxAST = scriptSyntaxAST;
+ this.rulesProvider = rulesProvider;
+ this.editorOptions = editorOptions;
+ this.logger = new TypeScript.LoggerAdapter(this.scriptSyntaxAST.getLogger());
+ this.sourceText = this.scriptSyntaxAST.getSourceText();
+ this.snapshot = new Formatting.TextSnapshot(this.scriptSyntaxAST.getScript(), this.sourceText);
+ this.fileAuthoringProxy = new Formatting.FileAuthoringProxy(this.scriptSyntaxAST);
+ this.tokenKindMap = Formatting.AuthorTokenKindMap.getInstance();
+ }
+ FormattingManager.prototype.FormatSelection = function (minChar, limChar) {
+ var span = new Formatting.SnapshotSpan(this.snapshot, Formatting.Span.FromBounds(minChar, limChar));
+ return this.Format(span, Formatting.FormattingRequestKind.FormatSelection, function (a, b) {
+ return true;
+ });
+ };
+ FormattingManager.prototype.FormatDocument = function (minChar, limChar) {
+ var span = new Formatting.SnapshotSpan(this.snapshot, Formatting.Span.FromBounds(minChar, limChar));
+ return this.Format(span, Formatting.FormattingRequestKind.FormatDocument, function (a, b) {
+ return true;
+ });
+ };
+ FormattingManager.prototype.FormatOnPaste = function (minChar, limChar) {
+ var span = new Formatting.SnapshotSpan(this.snapshot, Formatting.Span.FromBounds(minChar, limChar));
+ return this.Format(span, Formatting.FormattingRequestKind.FormatOnPaste, function (a, b) {
+ return true;
+ });
+ };
+ FormattingManager.prototype.CanFormatSpan = function (span) {
+ return true;
+ };
+ FormattingManager.prototype.FormatOnSemicolon = function (caretPosition) {
+ var _this = this;
+ var caret = new Formatting.SnapshotPoint(this.snapshot, caretPosition);
+ var semicolonPoint = caret.Add(-1);
+ var mappedPoint = this.MapDownSnapshotPoint(semicolonPoint);
+ if(mappedPoint !== null) {
+ var span = this.FindStatementSpan(mappedPoint, Formatting.FormattingRequestKind.FormatOnSemicolon);
+ if(span != null) {
+ return this.Format(span, Formatting.FormattingRequestKind.FormatOnSemicolon, function (tokens, requestKind) {
+ return !_this.IsInsideStringLiteralOrComment(mappedPoint, tokens);
+ });
+ }
+ }
+ return [];
+ };
+ FormattingManager.prototype.FormatOnClosingCurlyBrace = function (caretPosition) {
+ var _this = this;
+ var caret = new Formatting.SnapshotPoint(this.snapshot, caretPosition);
+ var closeBracePoint = caret.Add(-1);
+ var mappedPoint = this.MapDownSnapshotPoint(closeBracePoint);
+ if(mappedPoint !== null) {
+ var span = this.FindMatchingBlockSpan(mappedPoint, Formatting.FormattingRequestKind.FormatOnClosingCurlyBrace);
+ if(span != null) {
+ return this.Format(span, Formatting.FormattingRequestKind.FormatOnClosingCurlyBrace, function (tokens, requestKind) {
+ return !_this.IsInsideStringLiteralOrComment(mappedPoint, tokens);
+ });
+ }
+ }
+ return [];
+ };
+ FormattingManager.prototype.FormatOnEnter = function (caretPosition) {
+ var _this = this;
+ var lineNumber = this.snapshot.GetLineNumberFromPosition(caretPosition);
+ if(lineNumber > 0) {
+ var prevLine = this.snapshot.GetLineFromLineNumber(lineNumber - 1);
+ var currentLine = this.snapshot.GetLineFromLineNumber(lineNumber);
+ var span = new Formatting.SnapshotSpan(this.snapshot, Formatting.Span.FromBounds(prevLine.startPosition(), currentLine.endPosition()));
+ if(span != null) {
+ var caret = new Formatting.SnapshotPoint(this.snapshot, caretPosition);
+ var mappedPoint = this.MapDownSnapshotPoint(caret);
+ return this.Format(span, Formatting.FormattingRequestKind.FormatOnEnter, function (tokens, requestKind) {
+ return !_this.IsInsideStringLiteralOrComment(mappedPoint, tokens);
+ });
+ }
+ }
+ return [];
+ };
+ FormattingManager.prototype.FindMatchingBlockSpan = function (bracePoint, formattingRequestKind) {
+ var authoringProxy = this.fileAuthoringProxy;
+ var matchingBlockTask = new Formatting.MatchingBlockFinderTask(bracePoint, authoringProxy);
+ var blockSpan = matchingBlockTask.Run();
+ if(blockSpan !== null) {
+ return new Formatting.SnapshotSpan(bracePoint.snapshot, blockSpan);
+ } else {
+ return null;
+ }
+ };
+ FormattingManager.prototype.FindStatementSpan = function (semicolonPoint, formattingRequestKind) {
+ var authoringProxy = this.fileAuthoringProxy;
+ var statementFinderTask = new Formatting.StatementFinderTask(this.logger, semicolonPoint, authoringProxy);
+ statementFinderTask.Run();
+ if(statementFinderTask.BlockSpan != null) {
+ return new Formatting.SnapshotSpan(semicolonPoint.snapshot, statementFinderTask.BlockSpan);
+ } else {
+ return null;
+ }
+ };
+ FormattingManager.prototype.MapDownSnapshotSpan = function (snapshotSpan) {
+ return snapshotSpan;
+ };
+ FormattingManager.prototype.MapDownSnapshotPoint = function (snapshotPoint) {
+ return snapshotPoint;
+ };
+ FormattingManager.prototype.GetTokens = function (span) {
+ return Formatting.getTokensInSpan(this.logger, this.scriptSyntaxAST, this.tokenKindMap, span);
+ };
+ FormattingManager.prototype.IsInsideStringLiteralOrComment = function (point, tokens) {
+ if(point !== null) {
+ var span = new Formatting.Span(point.position, 1);
+ for(var i = 0; i < tokens.count(); i++) {
+ var token = tokens.get(i);
+ if(token.Span.OverlapsWith(span)) {
+ return token.Token == Formatting.AuthorTokenKind.atkString || token.Token == Formatting.AuthorTokenKind.atkComment;
+ }
+ }
+ }
+ return false;
+ };
+ FormattingManager.prototype.Format = function (span, formattingRequestKind, prerequisiteTokenTest) {
+ var _this = this;
+ if(span.IsEmpty() || !this.CanFormatSpan(span)) {
+ return [];
+ }
+ var scriptHasErrors = false;
+ if(scriptHasErrors) {
+ return [];
+ }
+ var startLinePoint = span.start().GetContainingLine().start();
+ span = new Formatting.SnapshotSpan(startLinePoint.snapshot, Formatting.Span.FromBounds(startLinePoint.position, span.endPosition()));
+ var tokens = TypeScript.timeFunction(this.logger, "FormattingManager: GetTokens()", function () {
+ return _this.GetTokens(span);
+ });
+ if(prerequisiteTokenTest != null && !prerequisiteTokenTest(tokens, formattingRequestKind)) {
+ return [];
+ }
+ var languageHostIndentation = null;
+ var editorOptions = this.editorOptions;
+ var formattingTask = new Formatting.FormattingTask(this.logger, this.snapshot, span, tokens, this.fileAuthoringProxy, this.rulesProvider, editorOptions, languageHostIndentation, scriptHasErrors, formattingRequestKind);
+ formattingTask.Run();
+ var result = [];
+ formattingTask.EditCommands.foreach(function (item) {
+ var edit = new Services.TextEdit(item.position, item.position + item.Length, item.replaceWith);
+ result.push(edit);
+ });
+ return result;
+ };
+ return FormattingManager;
+ })();
+ Formatting.FormattingManager = FormattingManager;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ (function (FormattingRequestKind) {
+ FormattingRequestKind._map = [];
+ FormattingRequestKind._map[0] = "FormatDocument";
+ FormattingRequestKind.FormatDocument = 0;
+ FormattingRequestKind._map[1] = "FormatSelection";
+ FormattingRequestKind.FormatSelection = 1;
+ FormattingRequestKind._map[2] = "FormatOnEnter";
+ FormattingRequestKind.FormatOnEnter = 2;
+ FormattingRequestKind._map[3] = "FormatOnSemicolon";
+ FormattingRequestKind.FormatOnSemicolon = 3;
+ FormattingRequestKind._map[4] = "FormatOnClosingCurlyBrace";
+ FormattingRequestKind.FormatOnClosingCurlyBrace = 4;
+ FormattingRequestKind._map[5] = "FormatOnPaste";
+ FormattingRequestKind.FormatOnPaste = 5;
+ })(Formatting.FormattingRequestKind || (Formatting.FormattingRequestKind = {}));
+ var FormattingRequestKind = Formatting.FormattingRequestKind;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var FormattingTask = (function () {
+ function FormattingTask(logger, Snapshot, span, tokens, fileAuthoringProxy, rulesProvider, editorOptions, languageHostIndentation, scriptHasErrors, formattingRequestKind) {
+ this.logger = logger;
+ this.Snapshot = Snapshot;
+ this.span = span;
+ this.tokens = tokens;
+ this.fileAuthoringProxy = fileAuthoringProxy;
+ this.rulesProvider = rulesProvider;
+ this.editorOptions = editorOptions;
+ this.languageHostIndentation = languageHostIndentation;
+ this.scriptHasErrors = scriptHasErrors;
+ this.formattingRequestKind = formattingRequestKind;
+ this.snapshotSpan = this.span;
+ this.tokenTags = this.tokens;
+ this.EditCommands = new Formatting.List_TextEditInfo();
+ }
+ FormattingTask.prototype.Run = function () {
+ var _this = this;
+ if(this.tokenTags.count() == 0) {
+ return;
+ }
+ var tree = TypeScript.timeFunction(this.logger, "FormattingTask: new ParseTree()", function () {
+ return new Formatting.ParseTree(_this.fileAuthoringProxy, _this.snapshotSpan.span, _this.tokenTags, false);
+ });
+ if(tree.Root == null) {
+ return;
+ }
+ TypeScript.timeFunction(this.logger, "FormattingTask: FillIndentationLevels()", function () {
+ Formatting.IndentationEdgeFinder.FillIndentationLevels(tree.Root);
+ });
+ TypeScript.timeFunction(this.logger, "FormattingTask: Format()", function () {
+ _this.Format(tree);
+ });
+ };
+ FormattingTask.prototype.Format = function (tree) {
+ var _this = this;
+ var tokenIndex = 0;
+ var token1Line = 0;
+ var currentLineNumber = -1;
+ var context = tree.Root;
+ Formatting.ParseTree.DumpTree(this.logger, tree.Root);
+ var sameLineIndent = false;
+ var t1 = this.tokenTags.get(0);
+ token1Line = t1.lineNumber();
+ var indenter = new Formatting.Indenter(this.logger, tree, this.Snapshot, this.languageHostIndentation, this.editorOptions, t1, false);
+ if(!this.scriptHasErrors) {
+ this.TrimWhitespaceInLineRange(t1, this.Snapshot.GetLineNumberFromPosition(this.snapshotSpan.startPosition()), token1Line - 1);
+ }
+ if(this.tokenTags.count() == 1) {
+ context = Formatting.ParseTree.FindCommonParentNode(t1.Span.span, t1.Span.span, context);
+ }
+ var formattingContext = new Formatting.FormattingContext(this.fileAuthoringProxy, this.Snapshot, this.tokenTags, this.formattingRequestKind);
+ for(tokenIndex = 1; tokenIndex < this.tokenTags.count(); tokenIndex++) {
+ if(this.logger.information()) {
+ this.logger.log("Processing token #" + tokenIndex + ": tokenId=" + (TypeScript.TokenID)._map[t1.tokenID] + ", span=[" + t1.Span.startPosition() + "," + t1.Span.endPosition() + "]");
+ }
+ var t2 = this.tokenTags.get(tokenIndex);
+ var token2Line = t2.lineNumber();
+ context = Formatting.ParseTree.FindCommonParentNode(t1.Span.span, t2.Span.span, context);
+ if(context.TokenTagIndex == null && context.AuthorNode.Details.StartOffset == t1.Span.span.start()) {
+ context.TokenTagIndex = tokenIndex - 1;
+ }
+ if(token1Line != currentLineNumber) {
+ var node = this.FindTokenNode(t1.Span.span, context);
+ var edits = indenter.GetIndentationEdits(t1, t2, node, sameLineIndent);
+ for(var i = 0; i < edits.count(); i++) {
+ this.EditCommands.add(edits.get(i));
+ }
+ currentLineNumber = token1Line;
+ sameLineIndent = false;
+ }
+ if(t1.Token == Formatting.AuthorTokenKind.atkComment || t1.Token == Formatting.AuthorTokenKind.atkString) {
+ currentLineNumber = this.Snapshot.GetLineNumberFromPosition(t1.Span.endPosition());
+ }
+ if(this.logger.information()) {
+ this.logger.log("Context node: " + context.toString());
+ }
+ if(!this.scriptHasErrors) {
+ formattingContext.setContext(context, t1, t2);
+ var rule = this.rulesProvider.getRulesMap().GetRule(formattingContext);
+ if(rule != null) {
+ this.GetRuleEdits(rule, t1, t2).foreach(function (edit) {
+ _this.EditCommands.add(edit);
+ });
+ if((rule.Operation.Action == Formatting.RuleAction.Space || rule.Operation.Action == Formatting.RuleAction.Delete) && token1Line != token2Line) {
+ var indent = indenter.GetLineIndentationForOffset(t1.Span.startPosition());
+ indenter.RegisterIndentation2(t2.Span.startPosition(), indent);
+ currentLineNumber = token2Line;
+ }
+ if(rule.Operation.Action == Formatting.RuleAction.NewLine && token1Line == token2Line) {
+ currentLineNumber = token2Line - 1;
+ sameLineIndent = true;
+ }
+ }
+ if(token1Line != token2Line) {
+ this.TrimWhitespaceInLineRange(t1, token1Line, token2Line - 1);
+ }
+ }
+ t1 = t2;
+ token1Line = token2Line;
+ }
+ if(token1Line != currentLineNumber) {
+ context = Formatting.ParseTree.FindCommonParentNode(t1.Span.span, t1.Span.span, context);
+ indenter.GetIndentationEdits(t1, null, context, sameLineIndent).foreach(function (edit) {
+ _this.EditCommands.add(edit);
+ });
+ }
+ if(!this.scriptHasErrors) {
+ var projectionEndLineSet = this.GetProjectionLineEndPositionSet();
+ if(!projectionEndLineSet.Contains(token1Line)) {
+ this.TrimWhitespace(t1);
+ var endlineNumber = this.Snapshot.GetLineNumberFromPosition(this.snapshotSpan.endPosition());
+ if(projectionEndLineSet.Contains(endlineNumber)) {
+ endlineNumber--;
+ }
+ this.TrimWhitespaceInLineRange(t1, token1Line + 1, endlineNumber);
+ }
+ }
+ };
+ FormattingTask.prototype.GetProjectionEndLines = function () {
+ var result = new Formatting.List_ITextSnapshotLine();
+ return result;
+ };
+ FormattingTask.prototype.GetProjectionLineEndPositionSet = function () {
+ var projectionEndLineSet = new Formatting.HashSet_int();
+ this.GetProjectionEndLines().foreach(function (line) {
+ if(!projectionEndLineSet.Contains(line.lineNumber())) {
+ projectionEndLineSet.Add(line.lineNumber());
+ }
+ });
+ return projectionEndLineSet;
+ };
+ FormattingTask.prototype.TrimWhitespaceInLineRange = function (token, startLine, endLine) {
+ for(var lineNumber = startLine; lineNumber <= endLine; ++lineNumber) {
+ var line = this.Snapshot.GetLineFromLineNumber(lineNumber);
+ this.TrimWhitespace2(token, line);
+ }
+ };
+ FormattingTask.prototype.TrimWhitespace = function (token) {
+ var line = this.Snapshot.GetLineFromPosition(token.Span.startPosition());
+ this.TrimWhitespace2(token, line);
+ };
+ FormattingTask.prototype.TrimWhitespace2 = function (token, line) {
+ if(token.Token == Formatting.AuthorTokenKind.atkComment && token.Span.startPosition() <= line.endPosition() && token.Span.endPosition() >= line.endPosition()) {
+ return;
+ }
+ var text = line.getText();
+ var index = 0;
+ for(index = text.length - 1; index >= 0; --index) {
+ if(!Formatting.EditorUtilities.IsWhitespace(text.charCodeAt(index))) {
+ break;
+ }
+ }
+ ++index;
+ if(index < text.length) {
+ var edit = new Formatting.TextEditInfo(line.startPosition() + index, line.length() - index, "");
+ if(this.logger.information()) {
+ this.logger.log("TrimWhiteSpace2()");
+ this.logger.log("edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" + TypeScript.stringToLiteral(edit.replaceWith, 30) + "\"");
+ }
+ this.EditCommands.add(edit);
+ }
+ };
+ FormattingTask.prototype.GetRuleEdits = function (rule, t1, t2) {
+ if(this.logger.information()) {
+ this.logger.log("GetRuleEdits(" + this.rulesProvider.getRuleName(rule) + ", " + "t1=[" + t1.Span.startPosition() + "," + t1.Span.endPosition() + "], " + "t2=[" + t2.Span.startPosition() + "," + t2.Span.endPosition() + "]" + ")");
+ }
+ var result = this.GetRuleEditsWorker(rule, t1, t2);
+ if(this.logger.information()) {
+ for(var i = 0; i < result.count(); i++) {
+ var edit = result.get(i);
+ this.logger.log("edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" + TypeScript.stringToLiteral(edit.replaceWith, 30) + "\"");
+ }
+ }
+ return result;
+ };
+ FormattingTask.prototype.GetRuleEditsWorker = function (rule, t1, t2) {
+ var emptyResult = new Formatting.List_TextEditInfo();
+ if(rule.Operation.Action == Formatting.RuleAction.Ignore) {
+ return emptyResult;
+ }
+ var betweenSpan;
+ switch(rule.Operation.Action) {
+ case Formatting.RuleAction.Delete:
+ {
+ betweenSpan = new Formatting.Span(t1.Span.endPosition(), t2.Span.startPosition() - t1.Span.endPosition());
+ if(betweenSpan.length() > 0) {
+ return new Formatting.List_TextEditInfo(new Formatting.TextEditInfo(betweenSpan.start(), betweenSpan.length(), ""));
+ }
+ }
+ break;
+ case Formatting.RuleAction.NewLine:
+ {
+ if(rule.Flag == Formatting.RuleFlags.CanDeleteNewLines) {
+ betweenSpan = new Formatting.Span(t1.Span.endPosition(), t2.Span.startPosition() - t1.Span.endPosition());
+ } else {
+ var lengthBetween;
+ if(t1.lineNumber() == t2.lineNumber()) {
+ lengthBetween = t2.Span.startPosition() - t1.Span.endPosition();
+ } else {
+ lengthBetween = t1.Span.end().GetContainingLine().endIncludingLineBreakPosition() - t1.Span.endPosition();
+ }
+ betweenSpan = new Formatting.Span(t1.Span.endPosition(), Formatting.Math.Max(0, lengthBetween));
+ }
+ var doEdit = false;
+ var betweenText = this.Snapshot.GetText(betweenSpan);
+ var lineFeedLoc = Formatting.StringUtils.IndexOf(betweenText, this.editorOptions.NewLineCharacter);
+ if(lineFeedLoc < 0) {
+ doEdit = true;
+ } else {
+ lineFeedLoc = Formatting.StringUtils.IndexOf(betweenText, this.editorOptions.NewLineCharacter, lineFeedLoc + 1);
+ if(lineFeedLoc >= 0) {
+ doEdit = true;
+ }
+ }
+ if(doEdit) {
+ return new Formatting.List_TextEditInfo(new Formatting.TextEditInfo(betweenSpan.start(), betweenSpan.length(), this.editorOptions.NewLineCharacter));
+ }
+ }
+ break;
+ case Formatting.RuleAction.Space:
+ {
+ if(rule.Flag == Formatting.RuleFlags.CanDeleteNewLines) {
+ betweenSpan = new Formatting.Span(t1.Span.endPosition(), t2.Span.startPosition() - t1.Span.endPosition());
+ } else {
+ var lengthBetween;
+ if(t1.lineNumber() == t2.lineNumber()) {
+ lengthBetween = t2.Span.startPosition() - t1.Span.endPosition();
+ } else {
+ lengthBetween = t1.Span.end().GetContainingLine().endPosition() - t1.Span.endPosition();
+ }
+ betweenSpan = new Formatting.Span(t1.Span.endPosition(), Formatting.Math.Max(0, lengthBetween));
+ }
+ if(betweenSpan.length() > 1 || this.Snapshot.GetText(betweenSpan) != " ") {
+ return new Formatting.List_TextEditInfo(new Formatting.TextEditInfo(betweenSpan.start(), betweenSpan.length(), " "));
+ }
+ }
+ break;
+ }
+ return emptyResult;
+ };
+ FormattingTask.prototype.FindTokenNode = function (span, helperNode) {
+ if(helperNode.CoverSpan(span)) {
+ if(helperNode.children() != null) {
+ var child = Formatting.ParseNodeExtensions.TryFindNodeForSpan(helperNode.children(), span);
+ if(child != null) {
+ return this.FindTokenNode(span, child);
+ }
+ }
+ return helperNode;
+ } else {
+ if(helperNode.Parent == null) {
+ return helperNode;
+ } else {
+ return this.FindTokenNode(span, helperNode.Parent);
+ }
+ }
+ };
+ return FormattingTask;
+ })();
+ Formatting.FormattingTask = FormattingTask;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var IndentationBag = (function () {
+ function IndentationBag(snapshot) {
+ this.snapshot = snapshot;
+ this.indentationEdits = new Formatting.Dictionary_int_List_IndentationEditInfo();
+ }
+ IndentationBag.prototype.AddIndent = function (edit) {
+ var line = this.snapshot.GetLineNumberFromPosition(edit.Position());
+ var lineIndents = this.indentationEdits.GetValue(line);
+ if(lineIndents === null) {
+ lineIndents = new Formatting.List_IndentationEditInfo();
+ this.indentationEdits.Add(line, lineIndents);
+ }
+ lineIndents.add(edit);
+ };
+ IndentationBag.prototype.FindIndent = function (position) {
+ var line = this.snapshot.GetLineNumberFromPosition(position);
+ var lineIndents = this.indentationEdits.GetValue(line);
+ if(lineIndents !== null) {
+ for(var i = lineIndents.count() - 1; i >= 0; i--) {
+ if(position >= lineIndents.get(i).Position()) {
+ return lineIndents.get(i);
+ }
+ }
+ }
+ return null;
+ };
+ return IndentationBag;
+ })();
+ Formatting.IndentationBag = IndentationBag;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var IndentationEdgeFinder = (function () {
+ function IndentationEdgeFinder() { }
+ IndentationEdgeFinder.FillIndentationLevels = function FillIndentationLevels(node) {
+ var nodeStack = new Formatting.Stack_ParseNode();
+ nodeStack.Push(node);
+ while(nodeStack.Count() > 0) {
+ IndentationEdgeFinder.FillIndentationLevels2(nodeStack.Pop(), nodeStack);
+ }
+ };
+ IndentationEdgeFinder.FillBodyIndentation = function FillBodyIndentation(node, nextNodesToVisit) {
+ node.IsIndentationOverrideEdge = true;
+ node.ChildrenIndentationDelta = 1;
+ Formatting.ParseNodeExtensions.ForAllChildren(Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneBody), function (child) {
+ if(child.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkEndCode) {
+ child.IndentationDelta = 1;
+ }
+ nextNodesToVisit.Push(child);
+ });
+ };
+ IndentationEdgeFinder.FillIndentationLevels2 = function FillIndentationLevels2(node, nextNodesToVisit) {
+ switch(node.AuthorNode.Details.nodeType) {
+ case TypeScript.NodeType.ModuleDeclaration:
+ case TypeScript.NodeType.ClassDeclaration:
+ case TypeScript.NodeType.InterfaceDeclaration:
+ IndentationEdgeFinder.FillBodyIndentation(node, nextNodesToVisit);
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ nextNodesToVisit.Push(child);
+ });
+ return;
+ case TypeScript.NodeType.ImportDeclaration:
+ node.ChildrenIndentationDelta = 1;
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ nextNodesToVisit.Push(child);
+ });
+ return;
+ }
+ switch(node.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkProg:
+ {
+ node.IndentationDelta = 0;
+ node.ChildrenIndentationDelta = 0;
+ var child = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneBody);
+ Formatting.ParseNodeExtensions.ForAllChildren(child, function (child) {
+ child.IndentationDelta = 0;
+ child.ChildrenIndentationDelta = 0;
+ nextNodesToVisit.Push(child);
+ });
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkBlock:
+ {
+ if((node.AuthorNode.Details.Flags & Formatting.AuthorParseNodeFlags.apnfSyntheticNode) != Formatting.AuthorParseNodeFlags.apnfSyntheticNode) {
+ IndentationEdgeFinder.FillIndentationEdgesForBlock(node, 1);
+ } else {
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ IndentationEdgeFinder.FillIndentationLevels(child);
+ });
+ node.IndentationDelta = null;
+ node.ChildrenIndentationDelta = null;
+ }
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkTryCatch:
+ case Formatting.AuthorParseNodeKind.apnkTryFinally:
+ {
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ IndentationEdgeFinder.FillIndentationLevels(child);
+ });
+ node.IndentationDelta = null;
+ node.ChildrenIndentationDelta = null;
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkFncDecl:
+ {
+ IndentationEdgeFinder.FillBodyIndentation(node, nextNodesToVisit);
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ {
+ node.ChildrenIndentationDelta = 1;
+ var col = Formatting.ParseNodeExtensions.GetChildren(node).Where(function (c) {
+ return c.AuthorNode.EdgeLabel == Formatting.AuthorParseNodeEdge.apneCase || c.AuthorNode.EdgeLabel == Formatting.AuthorParseNodeEdge.apneDefaultCase;
+ });
+ col.foreach(function (caseNode) {
+ caseNode.IndentationDelta = 1;
+ caseNode.ChildrenIndentationDelta = 1;
+ nextNodesToVisit.Push(caseNode);
+ });
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkCase:
+ case Formatting.AuthorParseNodeKind.apnkDefaultCase:
+ {
+ var child = Formatting.ParseNodeExtensions.FindChildWithEdge(Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneBody), Formatting.AuthorParseNodeEdge.apneBlockBody);
+ if(child != null) {
+ if(child.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkList) {
+ Formatting.ParseNodeExtensions.ForAllChildren(child, function (grandChild) {
+ grandChild.IndentationDelta = 1;
+ nextNodesToVisit.Push(grandChild);
+ });
+ } else if(child.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock) {
+ child.IndentationDelta = 1;
+ IndentationEdgeFinder.FillIndentationEdgesForBlock(child, 1);
+ } else {
+ child.IndentationDelta = 1;
+ nextNodesToVisit.Push(child);
+ }
+ }
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkIf:
+ {
+ node.ChildrenIndentationDelta = 1;
+ var thenChild = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneThen);
+ IndentationEdgeFinder.FillIndentationEdgesForBlockOrNot(thenChild, 1);
+ var elseChild = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneElse);
+ IndentationEdgeFinder.FillIndentationEdgesForBlockOrNot(elseChild, 1);
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkWhile:
+ case Formatting.AuthorParseNodeKind.apnkWith:
+ case Formatting.AuthorParseNodeKind.apnkDoWhile:
+ {
+ node.ChildrenIndentationDelta = 1;
+ var child = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneBody);
+ IndentationEdgeFinder.FillIndentationEdgesForBlockOrNot(child, 1);
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkObject:
+ {
+ node.IsIndentationOverrideEdge = true;
+ node.ChildrenIndentationDelta = 1;
+ var members = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneMembers);
+ if(members != null) {
+ if(members.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkList) {
+ Formatting.ParseNodeExtensions.ForAllChildren(members, function (grandChild) {
+ grandChild.ChildrenIndentationDelta = 1;
+ grandChild.IndentationDelta = 1;
+ nextNodesToVisit.Push(grandChild);
+ });
+ } else {
+ members.ChildrenIndentationDelta = 1;
+ members.IndentationDelta = 1;
+ nextNodesToVisit.Push(members);
+ }
+ }
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkArray:
+ {
+ node.IsIndentationOverrideEdge = true;
+ node.ChildrenIndentationDelta = 1;
+ var elements = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneElements);
+ if(elements != null) {
+ if(elements.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkList) {
+ Formatting.ParseNodeExtensions.ForAllChildren(elements, function (grandChild) {
+ grandChild.IsIndentationOverrideEdge = true;
+ nextNodesToVisit.Push(grandChild);
+ });
+ } else {
+ elements.IsIndentationOverrideEdge = true;
+ nextNodesToVisit.Push(elements);
+ }
+ }
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkTry:
+ case Formatting.AuthorParseNodeKind.apnkCatch:
+ case Formatting.AuthorParseNodeKind.apnkFinally:
+ {
+ node.ChildrenIndentationDelta = 1;
+ var body = Formatting.ParseNodeExtensions.FindChildWithEdge(node, Formatting.AuthorParseNodeEdge.apneBody);
+ if(body == null || (body != null && body.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkTryCatch && body.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkTryFinally)) {
+ var parent = node.Parent;
+ while(parent != null) {
+ if((parent.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkTryCatch || parent.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkTryFinally) && parent.IndentationDelta != null) {
+ node.IndentationDelta = parent.IndentationDelta;
+ break;
+ }
+ parent = parent.Parent;
+ }
+ }
+ if(body != null && body.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock) {
+ IndentationEdgeFinder.FillIndentationEdgesForBlock(body, 1);
+ } else {
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ nextNodesToVisit.Push(child);
+ });
+ }
+ }
+ break;
+ case Formatting.AuthorParseNodeKind.apnkAsg:
+ case Formatting.AuthorParseNodeKind.apnkAsgAdd:
+ case Formatting.AuthorParseNodeKind.apnkAsgSub:
+ case Formatting.AuthorParseNodeKind.apnkAsgMul:
+ case Formatting.AuthorParseNodeKind.apnkAsgDiv:
+ case Formatting.AuthorParseNodeKind.apnkAsgMod:
+ case Formatting.AuthorParseNodeKind.apnkAsgAnd:
+ case Formatting.AuthorParseNodeKind.apnkAsgXor:
+ case Formatting.AuthorParseNodeKind.apnkAsgOr:
+ case Formatting.AuthorParseNodeKind.apnkAsgLsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRs2:
+ case Formatting.AuthorParseNodeKind.apnkVarDecl:
+ case Formatting.AuthorParseNodeKind.apnkVarDeclList:
+ case Formatting.AuthorParseNodeKind.apnkCall:
+ case Formatting.AuthorParseNodeKind.apnkNew:
+ case Formatting.AuthorParseNodeKind.apnkDelete:
+ case Formatting.AuthorParseNodeKind.apnkReturn:
+ case Formatting.AuthorParseNodeKind.apnkDot:
+ case Formatting.AuthorParseNodeKind.apnkIndex:
+ {
+ if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkVarDecl && node.Parent != null && node.Parent.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkVarDeclList) {
+ } else {
+ node.ChildrenIndentationDelta = 1;
+ }
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ nextNodesToVisit.Push(child);
+ });
+ }
+ break;
+ default:
+ {
+ Formatting.ParseNodeExtensions.ForAllChildren(node, function (child) {
+ nextNodesToVisit.Push(child);
+ });
+ }
+ break;
+ }
+ };
+ IndentationEdgeFinder.FillIndentationEdgesForBlockOrNot = function FillIndentationEdgesForBlockOrNot(node, childrenLevel) {
+ if(node == null) {
+ return;
+ }
+ node.ChildrenIndentationDelta = childrenLevel;
+ if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock) {
+ IndentationEdgeFinder.FillIndentationEdgesForBlock(node, childrenLevel);
+ } else {
+ node.IndentationDelta = childrenLevel;
+ IndentationEdgeFinder.FillIndentationLevels(node);
+ }
+ };
+ IndentationEdgeFinder.FillIndentationEdgesForBlock = function FillIndentationEdgesForBlock(node, childrenLevel) {
+ if(node == null) {
+ return;
+ }
+ Formatting.Debug.Assert(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock, "Expecting a node of kind block.");
+ if((node.AuthorNode.Details.Flags & Formatting.AuthorParseNodeFlags.apnfSyntheticNode) != Formatting.AuthorParseNodeFlags.apnfSyntheticNode) {
+ node.ChildrenIndentationDelta = childrenLevel;
+ }
+ var child = Formatting.FirstOrDefault(Formatting.ParseNodeExtensions.GetChildren(node), function () {
+ return true;
+ });
+ if(child != null) {
+ if(child.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkList) {
+ Formatting.ParseNodeExtensions.ForAllChildren(child, function (grandChild) {
+ grandChild.IndentationDelta = node.ChildrenIndentationDelta;
+ IndentationEdgeFinder.FillIndentationLevels(grandChild);
+ });
+ } else {
+ child.IndentationDelta = node.ChildrenIndentationDelta;
+ IndentationEdgeFinder.FillIndentationLevels(child);
+ }
+ }
+ };
+ return IndentationEdgeFinder;
+ })();
+ Formatting.IndentationEdgeFinder = IndentationEdgeFinder;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var IndentationEditInfo = (function () {
+ function IndentationEditInfo(textEditInfo) {
+ this.textEditInfo = textEditInfo;
+ this.OrigIndentPosition = this.textEditInfo.Position;
+ }
+ IndentationEditInfo.prototype.Position = function () {
+ {
+ return this.textEditInfo.Position;
+ }
+ };
+ IndentationEditInfo.prototype.Indentation = function () {
+ {
+ return this.textEditInfo.ReplaceWith;
+ }
+ };
+ IndentationEditInfo.prototype.OrigIndentLength = function () {
+ {
+ return this.textEditInfo.Length;
+ }
+ };
+ IndentationEditInfo.create1 = function create1(textEditInfo) {
+ return new IndentationEditInfo(textEditInfo);
+ };
+ IndentationEditInfo.create2 = function create2(position, indentString, origPosition, origIndentLength) {
+ var textEditInfo = new Formatting.TextEditInfo(position, origIndentLength, indentString);
+ var result = new IndentationEditInfo(textEditInfo);
+ result.OrigIndentPosition = origPosition;
+ return result;
+ };
+ return IndentationEditInfo;
+ })();
+ Formatting.IndentationEditInfo = IndentationEditInfo;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var IndentationInfo = (function () {
+ function IndentationInfo(Prefix, Level) {
+ if (typeof Prefix === "undefined") { Prefix = null; }
+ if (typeof Level === "undefined") { Level = 0; }
+ this.Prefix = Prefix;
+ this.Level = Level;
+ }
+ return IndentationInfo;
+ })();
+ Formatting.IndentationInfo = IndentationInfo;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var Indenter = (function () {
+ function Indenter(logger, tree, snapshot, languageHostIndentation, editorOptions, firstToken, smartIndent) {
+ this.logger = logger;
+ this.tree = tree;
+ this.snapshot = snapshot;
+ this.languageHostIndentation = languageHostIndentation;
+ this.editorOptions = editorOptions;
+ this.firstToken = firstToken;
+ this.smartIndent = smartIndent;
+ this.indentationBag = new Formatting.IndentationBag(this.snapshot);
+ this.scriptBlockBeginLineNumber = -1;
+ this.offsetIndentationDeltas = new Formatting.Dictionary_int_int();
+ this.tree.Root.SetIndentationOverride("");
+ this.ApplyScriptBlockIndentation(this.languageHostIndentation, this.tree);
+ this.FillInheritedIndentation(this.tree);
+ }
+ Indenter.prototype.GetIndentationEdits = function (token, nextToken, node, sameLineIndent) {
+ if(this.logger.information()) {
+ this.logger.log("GetIndentationEdits(" + "t1=[" + token.Span.startPosition() + "," + token.Span.endPosition() + "], " + "t2=[" + (nextToken == null ? "null" : (nextToken.Span.startPosition() + "," + nextToken.Span.endPosition())) + "]" + ")");
+ }
+ var result = this.GetIndentationEditsWorker(token, nextToken, node, sameLineIndent);
+ if(this.logger.information()) {
+ for(var i = 0; i < result.count(); i++) {
+ var edit = result.get(i);
+ this.logger.log("edit: minChar=" + edit.position + ", limChar=" + (edit.position + edit.length) + ", text=\"" + TypeScript.stringToLiteral(edit.replaceWith, 30) + "\"");
+ }
+ }
+ return result;
+ };
+ Indenter.prototype.GetIndentationEditsWorker = function (token, nextToken, node, sameLineIndent) {
+ var result = new Formatting.List_TextEditInfo();
+ var indentationInfo = null;
+ this.AdjustStartOffsetIfNeeded(token, node);
+ if(this.scriptBlockBeginLineNumber == token.lineNumber()) {
+ return result;
+ }
+ if(!sameLineIndent && this.IsMultiLineString(token)) {
+ return result;
+ }
+ indentationInfo = this.GetSpecialCaseIndentation(token, node);
+ if(indentationInfo == null) {
+ while(!node.CanIndent() && node.Parent != null && token.Span.span.start() == node.Parent.AuthorNode.Details.StartOffset) {
+ node = node.Parent;
+ }
+ if(node.CanIndent() && token.Span.span.start() == node.AuthorNode.Details.StartOffset) {
+ indentationInfo = node.GetEffectiveIndentation(this);
+ } else {
+ if(token.Token == Formatting.AuthorTokenKind.atkIdentifier && nextToken != null && nextToken.Token == Formatting.AuthorTokenKind.atkColon) {
+ indentationInfo = node.GetEffectiveChildrenIndentation(this);
+ } else {
+ indentationInfo = this.ApplyIndentationDeltaFromParent(token, node);
+ }
+ }
+ }
+ if(indentationInfo != null) {
+ var edit = this.GetIndentEdit(indentationInfo, token.Span.startPosition(), sameLineIndent);
+ if(edit != null) {
+ this.RegisterIndentation(edit, sameLineIndent);
+ result.add(edit);
+ if(token.Token == Formatting.AuthorTokenKind.atkComment) {
+ var commentEdits = this.GetCommentIndentationEdits(token);
+ commentEdits.foreach(function (item) {
+ result.add(item);
+ });
+ }
+ }
+ }
+ return result;
+ };
+ Indenter.prototype.GetCommentIndentationEdits = function (token) {
+ var result = new Formatting.List_TextEditInfo();
+ if(token.Token != Formatting.AuthorTokenKind.atkComment) {
+ return result;
+ }
+ var commentLastLineNumber = this.snapshot.GetLineNumberFromPosition(token.Span.endPosition());
+ if(token.lineNumber() == commentLastLineNumber) {
+ return result;
+ }
+ var commentFirstLineIndentationDelta = this.GetIndentationDelta(token.Span.startPosition(), null);
+ if(commentFirstLineIndentationDelta != undefined) {
+ for(var line = token.lineNumber() + 1; line <= commentLastLineNumber; line++) {
+ var lineStartPosition = this.snapshot.GetLineFromLineNumber(line).startPosition();
+ var lineIndent = this.GetLineIndentationForOffset(lineStartPosition);
+ var commentIndentationInfo = this.ApplyIndentationDelta2(lineIndent, commentFirstLineIndentationDelta);
+ if(commentIndentationInfo != null) {
+ var tokenStartPosition = lineStartPosition + lineIndent.length;
+ var commentIndentationEdit = this.GetIndentEdit(commentIndentationInfo, tokenStartPosition, false);
+ if(commentIndentationEdit != null) {
+ result.add(commentIndentationEdit);
+ }
+ }
+ }
+ }
+ return result;
+ };
+ Indenter.GetIndentSizeFromIndentText = function GetIndentSizeFromIndentText(indentText, editorOptions) {
+ return Indenter.GetIndentSizeFromText(indentText, editorOptions, false);
+ };
+ Indenter.GetIndentSizeFromText = function GetIndentSizeFromText(text, editorOptions, includeNonIndentChars) {
+ var indentSize = 0;
+ for(var i = 0; i < text.length; i++) {
+ var c = text.charAt(i);
+ if(c == '\t') {
+ indentSize = (indentSize + editorOptions.TabSize) - (indentSize % editorOptions.TabSize);
+ } else if(c == ' ') {
+ indentSize += 1;
+ } else {
+ if(includeNonIndentChars) {
+ indentSize += 1;
+ } else {
+ break;
+ }
+ }
+ }
+ return indentSize;
+ };
+ Indenter.prototype.GetSpecialCaseIndentation = function (token, node) {
+ var indentationInfo = null;
+ switch(token.Token) {
+ case Formatting.AuthorTokenKind.atkLCurly:
+ indentationInfo = this.GetSpecialCaseIndentationForLCurly(node);
+ return indentationInfo;
+ case Formatting.AuthorTokenKind.atkElse:
+ case Formatting.AuthorTokenKind.atkRBrack:
+ indentationInfo = node.GetNodeStartLineIndentation(this);
+ return indentationInfo;
+ case Formatting.AuthorTokenKind.atkRCurly:
+ if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock && node.AuthorNode.EdgeLabel == Formatting.AuthorParseNodeEdge.apneBody) {
+ node = node.Parent;
+ }
+ indentationInfo = node.GetNodeStartLineIndentation(this);
+ return indentationInfo;
+ case Formatting.AuthorTokenKind.atkWhile:
+ if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkDoWhile) {
+ indentationInfo = node.GetNodeStartLineIndentation(this);
+ return indentationInfo;
+ }
+ return null;
+ case Formatting.AuthorTokenKind.atkSColon:
+ return this.GetSpecialCaseIndentationForSemicolon(token, node);
+ case Formatting.AuthorTokenKind.atkComment:
+ return this.GetSpecialCaseIndentationForComment(token, node);
+ default:
+ return indentationInfo;
+ }
+ };
+ Indenter.prototype.GetSpecialCaseIndentationForLCurly = function (node) {
+ var indentationInfo = null;
+ if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl || node.AuthorNode.EdgeLabel == Formatting.AuthorParseNodeEdge.apneThen || node.AuthorNode.EdgeLabel == Formatting.AuthorParseNodeEdge.apneElse) {
+ indentationInfo = node.GetNodeStartLineIndentation(this);
+ return indentationInfo;
+ } else if(node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkObject && !node.CanIndent()) {
+ return null;
+ }
+ indentationInfo = node.GetEffectiveIndentation(this);
+ return indentationInfo;
+ };
+ Indenter.prototype.GetSpecialCaseIndentationForSemicolon = function (token, node) {
+ var indentationInfo = null;
+ if(this.smartIndent) {
+ indentationInfo = node.GetEffectiveChildrenIndentation(this);
+ return indentationInfo;
+ } else {
+ if(node.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkFor) {
+ var semiColonStartSpan = new Formatting.Span(token.Span.startPosition(), 0);
+ node = Formatting.ParseTree.FindCommonParentNode(semiColonStartSpan, semiColonStartSpan, node);
+ indentationInfo = node.GetEffectiveChildrenIndentation(this);
+ return indentationInfo;
+ }
+ }
+ return null;
+ };
+ Indenter.prototype.GetSpecialCaseIndentationForComment = function (token, node) {
+ var indentationInfo = null;
+ var twoCharSpan = token.Span.Intersection(new Formatting.Span(token.Span.startPosition(), 2));
+ if(twoCharSpan != null && (twoCharSpan.GetText() == "//" || twoCharSpan.GetText() == "/*")) {
+ while(node.ChildrenIndentationDelta == null && node.Parent != null) {
+ node = node.Parent;
+ }
+ if(this.CanIndentComment(token, node)) {
+ indentationInfo = node.GetEffectiveChildrenIndentationForComment(this);
+ } else {
+ indentationInfo = this.ApplyIndentationDeltaFromParent(token, node);
+ }
+ }
+ return indentationInfo;
+ };
+ Indenter.prototype.CanIndentComment = function (token, node) {
+ switch(node.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkProg:
+ case Formatting.AuthorParseNodeKind.apnkBlock:
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ case Formatting.AuthorParseNodeKind.apnkCase:
+ case Formatting.AuthorParseNodeKind.apnkDefaultCase:
+ case Formatting.AuthorParseNodeKind.apnkIf:
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkWhile:
+ case Formatting.AuthorParseNodeKind.apnkWith:
+ case Formatting.AuthorParseNodeKind.apnkDoWhile:
+ case Formatting.AuthorParseNodeKind.apnkObject:
+ return true;
+ case Formatting.AuthorParseNodeKind.apnkFncDecl:
+ var result = true;
+ var children = Formatting.ParseNodeExtensions.FindChildrenWithEdge(node, Formatting.AuthorParseNodeEdge.apneArgument);
+ children.foreach(function (argumentNode) {
+ if(token.Span.startPosition() < argumentNode.AuthorNode.Details.StartOffset) {
+ result = false;
+ }
+ });
+ return result;
+ }
+ return false;
+ };
+ Indenter.prototype.ApplyScriptBlockIndentation = function (languageHostIndentation, tree) {
+ if(languageHostIndentation == null || tree.StartNodeSelf == null) {
+ return;
+ }
+ var scriptBlockIndentation = this.ApplyIndentationLevel(languageHostIndentation, 1);
+ tree.Root.SetIndentationOverride(scriptBlockIndentation);
+ };
+ Indenter.prototype.GetIndentEdit = function (indentInfo, tokenStartPosition, sameLineIndent) {
+ var indentText = this.ApplyIndentationLevel(indentInfo.Prefix, indentInfo.Level);
+ if(sameLineIndent) {
+ return new Formatting.TextEditInfo(tokenStartPosition, 0, indentText);
+ } else {
+ var snapshotLine = this.snapshot.GetLineFromPosition(tokenStartPosition);
+ var currentIndentSpan = new Formatting.Span(snapshotLine.startPosition(), tokenStartPosition - snapshotLine.startPosition());
+ var currentIndentText = this.snapshot.GetText(currentIndentSpan);
+ if(currentIndentText !== indentText) {
+ if(this.logger.debug()) {
+ for(var i = 0, len = currentIndentText.length; i < len; i++) {
+ var c = currentIndentText.charCodeAt(i);
+ if(!Formatting.StringUtils.IsWhiteSpace(c)) {
+ Formatting.Debug.Fail("Formatting error: Will remove user code when indenting the line: " + snapshotLine.getText());
+ break;
+ }
+ }
+ }
+ return new Formatting.TextEditInfo(currentIndentSpan.start(), currentIndentSpan.length(), indentText);
+ }
+ }
+ return null;
+ };
+ Indenter.prototype.ApplyIndentationLevel = function (existingIndentation, level) {
+ var indentSize = this.editorOptions.IndentSize;
+ var tabSize = this.editorOptions.TabSize;
+ var convertTabsToSpaces = this.editorOptions.ConvertTabsToSpaces;
+ if(level < 0) {
+ if(Formatting.StringUtils.IsNullOrEmpty(existingIndentation)) {
+ return "";
+ }
+ var totalIndent = 0;
+ Formatting.StringUtils.foreach(existingIndentation, function (c) {
+ if(c == '\t') {
+ totalIndent += tabSize;
+ } else {
+ totalIndent++;
+ }
+ });
+ totalIndent += level * indentSize;
+ if(totalIndent < 0) {
+ return "";
+ } else {
+ return this.GetIndentString(null, totalIndent, tabSize, convertTabsToSpaces);
+ }
+ }
+ var totalIndentSize = level * indentSize;
+ return this.GetIndentString(existingIndentation, totalIndentSize, tabSize, convertTabsToSpaces);
+ };
+ Indenter.prototype.GetIndentString = function (prefix, totalIndentSize, tabSize, convertTabsToSpaces) {
+ var tabString = convertTabsToSpaces ? Formatting.StringUtils.create(' ', tabSize) : "\t";
+ var text = "";
+ if(!Formatting.StringUtils.IsNullOrEmpty(prefix)) {
+ text += prefix;
+ }
+ var pos = 0;
+ while(pos <= totalIndentSize - tabSize) {
+ text += tabString;
+ pos += tabSize;
+ }
+ while(pos < totalIndentSize) {
+ text += ' ';
+ pos++;
+ }
+ return text;
+ };
+ Indenter.prototype.ApplyIndentationDeltaFromParent = function (token, node) {
+ var indentationInfo = null;
+ var indentableParent = node;
+ while(indentableParent != null && !indentableParent.CanIndent()) {
+ indentableParent = indentableParent.Parent;
+ }
+ if(indentableParent != null && indentableParent.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkProg) {
+ var parentIndentationDeltaSize = this.GetIndentationDelta(indentableParent.AuthorNode.Details.StartOffset, token.Span.startPosition());
+ if(parentIndentationDeltaSize !== undefined) {
+ indentationInfo = this.ApplyIndentationDelta1(token.Span.startPosition(), parentIndentationDeltaSize);
+ }
+ }
+ return indentationInfo;
+ };
+ Indenter.prototype.ApplyIndentationDelta1 = function (tokenStartPosition, delta) {
+ var snapshotLine = this.snapshot.GetLineFromPosition(tokenStartPosition);
+ var currentIndentSpan = new Formatting.Span(snapshotLine.startPosition(), tokenStartPosition - snapshotLine.startPosition());
+ var currentIndent = this.snapshot.GetText(currentIndentSpan);
+ return this.ApplyIndentationDelta2(currentIndent, delta);
+ };
+ Indenter.prototype.ApplyIndentationDelta2 = function (currentIndent, delta) {
+ if(delta == 0) {
+ return null;
+ }
+ var currentIndentSize = Indenter.GetIndentSizeFromIndentText(currentIndent, this.editorOptions);
+ var newIndentSize = currentIndentSize + delta;
+ if(newIndentSize < 0) {
+ newIndentSize = 0;
+ }
+ var newIndent = this.GetIndentString(null, newIndentSize, this.editorOptions.TabSize, this.editorOptions.ConvertTabsToSpaces);
+ if(newIndent != null) {
+ return new Formatting.IndentationInfo(newIndent, 0);
+ }
+ return null;
+ };
+ Indenter.prototype.GetIndentationDelta = function (tokenStartPosition, childTokenStartPosition) {
+ Formatting.Debug.Assert(childTokenStartPosition !== undefined, "Error: caller must pass 'null' for undefined position");
+ var indentationDeltaSize = this.offsetIndentationDeltas.GetValue(tokenStartPosition);
+ if(indentationDeltaSize === null) {
+ var indentEditInfo = this.indentationBag.FindIndent(tokenStartPosition);
+ if(indentEditInfo == null) {
+ return null;
+ }
+ var origIndentText = this.snapshot.GetText(new Formatting.Span(indentEditInfo.OrigIndentPosition, indentEditInfo.OrigIndentLength()));
+ var newIndentText = indentEditInfo.Indentation();
+ var origIndentSize = Indenter.GetIndentSizeFromText(origIndentText, this.editorOptions, true);
+ var newIndentSize = Indenter.GetIndentSizeFromIndentText(newIndentText, this.editorOptions);
+ if(childTokenStartPosition !== null) {
+ var childTokenLineStartPosition = this.snapshot.GetLineFromPosition(childTokenStartPosition).startPosition();
+ var childIndentText = this.snapshot.GetText(new Formatting.Span(childTokenLineStartPosition, childTokenStartPosition - childTokenLineStartPosition));
+ var childIndentSize = Indenter.GetIndentSizeFromIndentText(childIndentText, this.editorOptions);
+ if(childIndentSize < origIndentSize) {
+ origIndentSize = Indenter.GetIndentSizeFromIndentText(origIndentText, this.editorOptions);
+ }
+ }
+ indentationDeltaSize = newIndentSize - origIndentSize;
+ this.offsetIndentationDeltas.Add(tokenStartPosition, indentationDeltaSize);
+ }
+ return indentationDeltaSize;
+ };
+ Indenter.prototype.FillInheritedIndentation = function (tree) {
+ var offset = -1;
+ var indentNode = null;
+ if(tree.StartNodeSelf != null) {
+ if(!this.smartIndent && tree.StartNodePreviousSibling !== null && tree.StartNodeSelf.AuthorNode.Label == 0 && tree.StartNodePreviousSibling.Label == 0) {
+ indentNode = tree.StartNodeSelf;
+ offset = tree.StartNodePreviousSibling.Details.StartOffset;
+ var lineNum = this.snapshot.GetLineNumberFromPosition(offset);
+ var node = indentNode;
+ while(node.Parent != null && this.snapshot.GetLineNumberFromPosition(node.Parent.AuthorNode.Details.StartOffset) == lineNum) {
+ node = node.Parent;
+ if(node.CanIndent()) {
+ indentNode = node;
+ indentNode.IndentationDelta = 0;
+ }
+ }
+ } else {
+ var parent;
+ if(this.smartIndent) {
+ parent = tree.StartNodeSelf;
+ while(parent != null && parent.AuthorNode.Details.StartOffset == this.firstToken.Span.startPosition()) {
+ parent = parent.Parent;
+ }
+ } else {
+ var startNodeLineNumber = this.snapshot.GetLineNumberFromPosition(tree.StartNodeSelf.AuthorNode.Details.StartOffset);
+ parent = tree.StartNodeSelf.Parent;
+ while(parent != null && startNodeLineNumber == this.snapshot.GetLineNumberFromPosition(parent.AuthorNode.Details.StartOffset)) {
+ parent = parent.Parent;
+ }
+ }
+ while(parent != null && !parent.CanIndent()) {
+ parent = parent.Parent;
+ }
+ if(parent != null && parent.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkProg) {
+ offset = parent.AuthorNode.Details.StartOffset;
+ indentNode = parent;
+ }
+ }
+ }
+ if(indentNode != null) {
+ var indentOverride = this.GetLineIndentationForOffset(offset);
+ if(!this.smartIndent && tree.StartNodePreviousSibling !== null && indentNode.Parent != null) {
+ Formatting.ParseNodeExtensions.GetChildren(indentNode.Parent).foreach(function (sibling) {
+ if(sibling !== indentNode) {
+ if(sibling.CanIndent()) {
+ sibling.SetIndentationOverride(indentOverride);
+ }
+ }
+ });
+ }
+ var lastDelta = 0;
+ var lastLine = this.snapshot.GetLineNumberFromPosition(indentNode.AuthorNode.Details.StartOffset);
+ do {
+ var currentLine = this.snapshot.GetLineNumberFromPosition(indentNode.AuthorNode.Details.StartOffset);
+ if(lastLine != currentLine) {
+ lastLine = currentLine;
+ indentOverride = this.ApplyIndentationLevel(indentOverride, -lastDelta);
+ lastDelta = 0;
+ }
+ if(indentNode.CanIndent()) {
+ indentNode.SetIndentationOverride(indentOverride);
+ lastDelta = indentNode.IndentationDelta;
+ }
+ indentNode = indentNode.Parent;
+ }while(indentNode != null);
+ }
+ };
+ Indenter.prototype.GetLineIndentationForOffset = function (offset) {
+ var indentationEdit;
+ indentationEdit = this.indentationBag.FindIndent(offset);
+ if(indentationEdit != null) {
+ return indentationEdit.Indentation();
+ } else {
+ var line = this.snapshot.GetLineFromPosition(offset);
+ var lineText = line.getText();
+ var index = 0;
+ while(index < lineText.length && (lineText.charAt(index) == ' ' || lineText.charAt(index) == '\t')) {
+ ++index;
+ }
+ return lineText.substr(0, index);
+ }
+ };
+ Indenter.prototype.RegisterIndentation = function (indent, sameLineIndent) {
+ var indentationInfo = null;
+ if(sameLineIndent) {
+ var lineStartPosition = this.snapshot.GetLineFromPosition(indent.Position).startPosition();
+ var lineIndentLength = indent.Position - lineStartPosition;
+ indentationInfo = Formatting.IndentationEditInfo.create2(indent.Position, indent.ReplaceWith, lineStartPosition, lineIndentLength);
+ } else {
+ indentationInfo = new Formatting.IndentationEditInfo(indent);
+ }
+ this.indentationBag.AddIndent(indentationInfo);
+ };
+ Indenter.prototype.RegisterIndentation2 = function (position, indent) {
+ this.RegisterIndentation(new Formatting.TextEditInfo(position, 0, indent), false);
+ };
+ Indenter.prototype.AdjustStartOffsetIfNeeded = function (token, node) {
+ if(token == null) {
+ return;
+ }
+ var updateStartOffset = false;
+ switch(token.Token) {
+ case Formatting.AuthorTokenKind.atkFunction:
+ updateStartOffset = node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl;
+ break;
+ case Formatting.AuthorTokenKind.atkLCurly:
+ updateStartOffset = node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkObject;
+ break;
+ case Formatting.AuthorTokenKind.atkLBrack:
+ updateStartOffset = node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkArray;
+ break;
+ }
+ if(updateStartOffset) {
+ Formatting.ParseNodeExtensions.SetNodeSpan(node, token.Span.startPosition(), node.AuthorNode.Details.EndOffset);
+ }
+ };
+ Indenter.prototype.IsMultiLineString = function (token) {
+ return token.tokenID === TypeScript.TokenID.StringLiteral && this.snapshot.GetLineNumberFromPosition(token.Span.endPosition()) > this.snapshot.GetLineNumberFromPosition(token.Span.startPosition());
+ };
+ return Indenter;
+ })();
+ Formatting.Indenter = Indenter;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var MatchingBlockFinderTask = (function () {
+ function MatchingBlockFinderTask(bracePoint, FileAuthoringProxy) {
+ this.bracePoint = bracePoint;
+ this.FileAuthoringProxy = FileAuthoringProxy;
+ }
+ MatchingBlockFinderTask.prototype.Run = function () {
+ var parseCursor = this.FileAuthoringProxy.GetASTCursor();
+ parseCursor.SeekToOffset(this.bracePoint.position, true);
+ return this.FindMatchingBlockSpan(parseCursor);
+ };
+ MatchingBlockFinderTask.prototype.FindMatchingBlockSpan = function (parser) {
+ var currentNode = parser.Current();
+ while(currentNode.Kind != Formatting.AuthorParseNodeKind.apnkEmptyNode) {
+ if(currentNode.ast != null) {
+ switch(currentNode.ast.nodeType) {
+ case TypeScript.NodeType.InterfaceDeclaration:
+ case TypeScript.NodeType.ClassDeclaration:
+ case TypeScript.NodeType.ModuleDeclaration:
+ return Formatting.Span.FromBounds(currentNode.ast.minChar, currentNode.ast.limChar);
+ case TypeScript.NodeType.ImportDeclaration:
+ return new Formatting.Span(currentNode.StartOffset, currentNode.EndOffset - currentNode.StartOffset);
+ }
+ }
+ switch(currentNode.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkProg:
+ return null;
+ case Formatting.AuthorParseNodeKind.apnkVarDecl:
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ case Formatting.AuthorParseNodeKind.apnkCase:
+ case Formatting.AuthorParseNodeKind.apnkDefaultCase:
+ case Formatting.AuthorParseNodeKind.apnkTry:
+ case Formatting.AuthorParseNodeKind.apnkCatch:
+ case Formatting.AuthorParseNodeKind.apnkFinally:
+ case Formatting.AuthorParseNodeKind.apnkIf:
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkWhile:
+ case Formatting.AuthorParseNodeKind.apnkDoWhile:
+ case Formatting.AuthorParseNodeKind.apnkWith:
+ case Formatting.AuthorParseNodeKind.apnkCall:
+ case Formatting.AuthorParseNodeKind.apnkReturn:
+ case Formatting.AuthorParseNodeKind.apnkAsg:
+ case Formatting.AuthorParseNodeKind.apnkAsgAdd:
+ case Formatting.AuthorParseNodeKind.apnkAsgSub:
+ case Formatting.AuthorParseNodeKind.apnkAsgMul:
+ case Formatting.AuthorParseNodeKind.apnkAsgDiv:
+ case Formatting.AuthorParseNodeKind.apnkAsgMod:
+ case Formatting.AuthorParseNodeKind.apnkAsgAnd:
+ case Formatting.AuthorParseNodeKind.apnkAsgXor:
+ case Formatting.AuthorParseNodeKind.apnkAsgOr:
+ case Formatting.AuthorParseNodeKind.apnkAsgLsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRs2:
+ return new Formatting.Span(currentNode.StartOffset, currentNode.EndOffset - currentNode.StartOffset);
+ case Formatting.AuthorParseNodeKind.apnkBlock:
+ if((currentNode.Flags & Formatting.AuthorParseNodeFlags.apnfSyntheticNode) != Formatting.AuthorParseNodeFlags.apnfSyntheticNode) {
+ var parent = parser.Parent();
+ switch(parent.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkBlock:
+ case Formatting.AuthorParseNodeKind.apnkList:
+ return new Formatting.Span(currentNode.StartOffset, currentNode.EndOffset - currentNode.StartOffset);
+ }
+ }
+ currentNode = parser.MoveUp();
+ continue;
+ case Formatting.AuthorParseNodeKind.apnkFncDecl: {
+ var start = parser.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpFunctionKeywordMin);
+ start = (start == 0) ? currentNode.StartOffset : start;
+ var end = parser.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpRCurlyMin);
+ end = (end == 0) ? currentNode.EndOffset : end + 1;
+ return new Formatting.Span(start, end - start);
+ }
+ case Formatting.AuthorParseNodeKind.apnkObject: {
+ var start = parser.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpLCurlyMin);
+ start = (start == 0) ? currentNode.StartOffset : start;
+ var end = parser.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpRCurlyMin);
+ end = (end == 0) ? currentNode.EndOffset : end + 1;
+ return new Formatting.Span(start, end - start);
+ }
+ default:
+ currentNode = parser.MoveUp();
+ continue;
+ }
+ }
+ return null;
+ };
+ return MatchingBlockFinderTask;
+ })();
+ Formatting.MatchingBlockFinderTask = MatchingBlockFinderTask;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var ParseNode = (function () {
+ function ParseNode() {
+ this._children = null;
+ this.blockSpan = null;
+ this.indentationOverride = null;
+ this.Parent = null;
+ this.AuthorNode = null;
+ this.IsIndentationOverrideEdge = false;
+ this.IndentationDelta = null;
+ this.ChildrenIndentationDelta = null;
+ this.TokenTagIndex = null;
+ }
+ ParseNode.prototype.children = function () {
+ return this._children;
+ };
+ ParseNode.prototype.addChildNode = function (node) {
+ if(this._children === null) {
+ this._children = new Formatting.List_ParseNode();
+ }
+ var count = this._children.count();
+ if(count === 0) {
+ this._children.add(node);
+ } else {
+ var startOffset = node.AuthorNode.Details.StartOffset;
+ var maxOffset = this._children.get(count - 1).AuthorNode.Details.StartOffset;
+ if(startOffset >= maxOffset) {
+ this._children.add(node);
+ } else {
+ var pivot = Formatting.ParseNodeExtensions.findNodeInsertionPivot(this._children, node.AuthorNode.Details.StartOffset);
+ if(pivot < 0) {
+ this._children.insert(~pivot, node);
+ } else {
+ this._children.insert(pivot + 1, node);
+ }
+ }
+ }
+ };
+ ParseNode.prototype.CanIndent = function () {
+ {
+ return this.IndentationDelta != null;
+ }
+ };
+ ParseNode.prototype.CoverSpan = function (span) {
+ var details = this.AuthorNode.Details;
+ return span.start() >= details.StartOffset && span.end() <= details.EndOffset;
+ };
+ ParseNode.prototype.SetIndentationOverride = function (newIndentationOverride) {
+ this.indentationOverride = newIndentationOverride;
+ };
+ ParseNode.prototype.GetNodeStartLineIndentation = function (indentResolver) {
+ var node = this;
+ var prefix = null;
+ while(node != null && !node.CanIndent() && !node.IsIndentationOverrideEdge) {
+ node = node.Parent;
+ }
+ if(node != null) {
+ if(node.indentationOverride == null) {
+ node.indentationOverride = indentResolver.GetLineIndentationForOffset(node.AuthorNode.Details.StartOffset);
+ }
+ prefix = node.indentationOverride;
+ }
+ return new Formatting.IndentationInfo(prefix, 0);
+ };
+ ParseNode.prototype.GetEffectiveIndentation = function (indentResolver) {
+ var node = this;
+ var prefix = null;
+ var level = 0;
+ while(node != null && !node.CanIndent() && !node.IsIndentationOverrideEdge) {
+ node = node.Parent;
+ }
+ if(node != null) {
+ if(node.indentationOverride != null) {
+ prefix = node.indentationOverride;
+ } else {
+ if(node.CanIndent()) {
+ level = node.IndentationDelta;
+ if(!!node.AuthorNode.Label) {
+ level++;
+ }
+ node = node.Parent;
+ while(node != null) {
+ if(node.indentationOverride != null) {
+ prefix = node.indentationOverride;
+ break;
+ }
+ if(node.CanIndent() || node.IsIndentationOverrideEdge) {
+ node.indentationOverride = indentResolver.GetLineIndentationForOffset(node.AuthorNode.Details.StartOffset);
+ prefix = node.indentationOverride;
+ break;
+ }
+ node = node.Parent;
+ }
+ } else if(node.IsIndentationOverrideEdge) {
+ node.indentationOverride = indentResolver.GetLineIndentationForOffset(node.AuthorNode.Details.StartOffset);
+ prefix = node.indentationOverride;
+ }
+ }
+ }
+ return new Formatting.IndentationInfo(prefix, level);
+ };
+ ParseNode.prototype.GetEffectiveChildrenIndentation = function (indentResolver) {
+ var node = this;
+ var indentation = null;
+ while(node.ChildrenIndentationDelta == null && node.Parent != null) {
+ node = node.Parent;
+ }
+ if(node.ChildrenIndentationDelta != null) {
+ indentation = node.GetEffectiveIndentation(indentResolver);
+ indentation.Level += node.ChildrenIndentationDelta;
+ }
+ return indentation;
+ };
+ ParseNode.prototype.GetEffectiveChildrenIndentationForComment = function (indentResolver) {
+ var node = this;
+ var indentation = null;
+ while(node.Parent != null && (node.ChildrenIndentationDelta == null || node.IndentationDelta == null) && !ParseNode.IsNonIndentableException(node)) {
+ node = node.Parent;
+ }
+ if(node.ChildrenIndentationDelta != null) {
+ indentation = new Formatting.IndentationInfo();
+ indentation.Level = node.ChildrenIndentationDelta;
+ if(this.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkProg) {
+ indentation.Prefix = indentResolver.GetLineIndentationForOffset(node.AuthorNode.Details.StartOffset);
+ }
+ }
+ return indentation;
+ };
+ ParseNode.IsNonIndentableException = function IsNonIndentableException(node) {
+ return node.IndentationDelta == null && (node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkObject || node.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl);
+ };
+ ParseNode.prototype.GetBlockSpan = function (fileAuthoringProxy, tokens) {
+ if(this.blockSpan != null) {
+ return this.blockSpan;
+ }
+ var start = this.AuthorNode.Details.StartOffset;
+ var end = this.AuthorNode.Details.EndOffset;
+ var implicitBlockNode = null;
+ if(this.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl || this.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkSwitch) {
+ implicitBlockNode = this;
+ } else if(this.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkList && this.Parent != null && this.Parent.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl) {
+ implicitBlockNode = this.Parent;
+ }
+ if(implicitBlockNode != null) {
+ if(implicitBlockNode.TokenTagIndex != null) {
+ var functionTokenIndex = implicitBlockNode.TokenTagIndex;
+ for(var i = functionTokenIndex + 1; i < tokens.count(); i++) {
+ if(tokens.get(i).Token == Formatting.AuthorTokenKind.atkLCurly && tokens.get(i).Span.startPosition() <= end) {
+ start = tokens.get(i).Span.startPosition();
+ break;
+ }
+ }
+ } else {
+ var astCursor = fileAuthoringProxy.GetASTCursor();
+ {
+ astCursor.MoveToEnclosingNode(implicitBlockNode.AuthorNode.Details.StartOffset, implicitBlockNode.AuthorNode.Details.EndOffset);
+ var leftCurlyPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpLCurlyMin);
+ if(leftCurlyPos != 0 && leftCurlyPos <= end) {
+ start = leftCurlyPos;
+ }
+ }
+ }
+ } else if(this.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkBlock) {
+ var found = false;
+ Formatting.ParseNodeExtensions.GetChildren(this).foreach(function (child) {
+ if(child.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock) {
+ if(!found) {
+ found = true;
+ start = child.AuthorNode.Details.StartOffset;
+ end = child.AuthorNode.Details.EndOffset;
+ }
+ }
+ });
+ }
+ Formatting.Debug.Assert(start <= end, "Expecting start to be before end.");
+ this.blockSpan = new Formatting.Span(start, end - start);
+ return this.blockSpan;
+ };
+ ParseNode.prototype.toString = function () {
+ var text = this.AuthorNode.Level + ": " + (Formatting.AuthorParseNodeKind)._map[this.AuthorNode.Details.Kind] + " - " + (TypeScript.NodeType)._map[this.AuthorNode.Details.nodeType] + " (" + (Formatting.AuthorParseNodeEdge)._map[this.AuthorNode.EdgeLabel] + ") -- I:" + this.IndentationDelta + ",IC:" + this.ChildrenIndentationDelta + " -- (" + this.AuthorNode.Details.StartOffset + "," + this.AuthorNode.Details.EndOffset + ") -- F:(" + this.AuthorNode.Details.Flags + ")";
+ return text;
+ };
+ return ParseNode;
+ })();
+ Formatting.ParseNode = ParseNode;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var ParseNodeExtensions = (function () {
+ function ParseNodeExtensions() { }
+ ParseNodeExtensions.GetChildren = function GetChildren(node) {
+ if(node == null || node.children() == null) {
+ return new Formatting.List_ParseNode();
+ }
+ return node.children();
+ };
+ ParseNodeExtensions.FindChildrenWithEdge = function FindChildrenWithEdge(node, edge) {
+ var result = new Formatting.List_ParseNode();
+ ParseNodeExtensions.GetChildren(node).foreach(function (item) {
+ if(item.AuthorNode.EdgeLabel == edge) {
+ result.add(item);
+ }
+ });
+ return result;
+ };
+ ParseNodeExtensions.FindChildWithEdge = function FindChildWithEdge(node, edge) {
+ return Formatting.FirstOrDefault(ParseNodeExtensions.GetChildren(node).Where(function (c) {
+ return c.AuthorNode.EdgeLabel == edge;
+ }), function () {
+ return true;
+ });
+ };
+ ParseNodeExtensions.ForAllChildren = function ForAllChildren(node, action) {
+ ParseNodeExtensions.GetChildren(node).foreach(action);
+ };
+ ParseNodeExtensions.comparer = function comparer(position, item) {
+ return position - item.AuthorNode.Details.StartOffset;
+ };
+ ParseNodeExtensions.findNodeInsertionPivot = function findNodeInsertionPivot(nodes, startOffset) {
+ if(nodes.count() == 0) {
+ return 0;
+ }
+ return Formatting.BinarySearch(nodes, startOffset, ParseNodeExtensions.comparer);
+ };
+ ParseNodeExtensions.TryFindNodeIndexForStartOffset = function TryFindNodeIndexForStartOffset(nodes, startOffset) {
+ var targetNodeIndex = -1;
+ if(nodes.count() > 0) {
+ var pivot = Formatting.BinarySearch(nodes, startOffset, ParseNodeExtensions.comparer);
+ if(pivot < 0) {
+ pivot = ~pivot - 1;
+ targetNodeIndex = pivot;
+ } else {
+ targetNodeIndex = pivot;
+ }
+ }
+ return targetNodeIndex;
+ };
+ ParseNodeExtensions.TryFindNodeForSpan = function TryFindNodeForSpan(nodes, span) {
+ var nodeIndex = ParseNodeExtensions.TryFindNodeIndexForStartOffset(nodes, span.start());
+ if(nodeIndex >= 0 && nodeIndex < nodes.count()) {
+ var node = nodes.get(nodeIndex);
+ if(node.CoverSpan(span)) {
+ return node;
+ }
+ }
+ return null;
+ };
+ ParseNodeExtensions.SetNodeSpan = function SetNodeSpan(node, newStartOffset, newEndOffset) {
+ var authorParseNode = node.AuthorNode;
+ if(newStartOffset != authorParseNode.Details.StartOffset || newEndOffset != authorParseNode.Details.EndOffset) {
+ var newAuthorNode = new Formatting.AuthorParseNode();
+ newAuthorNode.Details = new Formatting.AuthorParseNodeDetails();
+ newAuthorNode.Details.StartOffset = newStartOffset;
+ newAuthorNode.Details.EndOffset = newEndOffset;
+ newAuthorNode.Details.Flags = authorParseNode.Details.Flags;
+ newAuthorNode.Details.Kind = authorParseNode.Details.Kind;
+ newAuthorNode.Details.nodeType = authorParseNode.Details.nodeType;
+ newAuthorNode.Details.ast = authorParseNode.Details.ast;
+ newAuthorNode.EdgeLabel = authorParseNode.EdgeLabel;
+ newAuthorNode.Label = authorParseNode.Label;
+ newAuthorNode.Level = authorParseNode.Level;
+ newAuthorNode.Name = authorParseNode.Name;
+ node.AuthorNode = newAuthorNode;
+ }
+ };
+ return ParseNodeExtensions;
+ })();
+ Formatting.ParseNodeExtensions = ParseNodeExtensions;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var ParseTree = (function () {
+ function ParseTree(fileAuthoringProxy, span, tokens, onlySelfAndAncestors) {
+ this.StartNodeSelf = null;
+ this.StartNodePreviousSibling = null;
+ if(tokens != null) {
+ var firstToken = Formatting.FirstOrDefault(tokens, function (t) {
+ return t.Span.startPosition() >= span.start() && t.Token != Formatting.AuthorTokenKind.atkComment && t.Token != Formatting.AuthorTokenKind.atkSColon && t.Token != Formatting.AuthorTokenKind.atkComma;
+ });
+ if(firstToken != null) {
+ var firstTokenStart = firstToken.Span.Start;
+ var lastToken = Formatting.LastOrDefault(tokens, function (t) {
+ return t.Span.endPosition() <= span.end() && t.Token != Formatting.AuthorTokenKind.atkComment && t.Token != Formatting.AuthorTokenKind.atkSColon && t.Token != Formatting.AuthorTokenKind.atkComma;
+ });
+ if(lastToken != null) {
+ var lastTokenEnd = lastToken.Span.End;
+ if(firstTokenStart < lastTokenEnd) {
+ span = new Formatting.Span(firstTokenStart, lastTokenEnd - firstTokenStart);
+ }
+ }
+ }
+ }
+ this.Initialize(fileAuthoringProxy, span, onlySelfAndAncestors);
+ }
+ ParseTree.FindCommonParentNode = function FindCommonParentNode(leftSpan, rightSpan, context) {
+ if(context.CoverSpan(leftSpan) && context.CoverSpan(rightSpan)) {
+ Formatting.Debug.Assert(leftSpan.start() <= rightSpan.start(), "left token should be before the right token");
+ if(context.children() != null) {
+ var child = Formatting.ParseNodeExtensions.TryFindNodeForSpan(context.children(), leftSpan);
+ if(child != null && child.CoverSpan(rightSpan)) {
+ return ParseTree.FindCommonParentNode(leftSpan, rightSpan, child);
+ }
+ }
+ return context;
+ } else {
+ if(context.Parent == null) {
+ return context;
+ } else {
+ return ParseTree.FindCommonParentNode(leftSpan, rightSpan, context.Parent);
+ }
+ }
+ };
+ ParseTree.prototype.Initialize = function (fileAuthoringProxy, span, onlySelfAndAncestors) {
+ var astCursor = fileAuthoringProxy.GetASTCursor();
+ {
+ if(span.length() == 0) {
+ astCursor.SeekToOffset(span.start(), false);
+ } else {
+ astCursor.MoveToEnclosingNode(span.start(), span.end());
+ }
+ var selfAndDescendantsNodes = new Formatting.List_ParseNode();
+ var parseNodeSet = astCursor.GetSubTree(onlySelfAndAncestors ? 0 : -1);
+ {
+ if(parseNodeSet.Count() > 0) {
+ var authorNodes = parseNodeSet.GetItems(0, parseNodeSet.Count());
+ if(authorNodes[0].Details.Kind != Formatting.AuthorParseNodeKind.apnkEndCode) {
+ var nodeEdge = astCursor.GetEdgeLabel();
+ if(nodeEdge != Formatting.AuthorParseNodeEdge.apneNone) {
+ var newAuthorNode = new Formatting.AuthorParseNode();
+ newAuthorNode.Level = 0;
+ newAuthorNode.Label = authorNodes[0].Label;
+ newAuthorNode.Name = authorNodes[0].Name;
+ newAuthorNode.Details = authorNodes[0].Details;
+ newAuthorNode.EdgeLabel = nodeEdge;
+ authorNodes[0] = newAuthorNode;
+ }
+ }
+ authorNodes.forEach(function (authorParseNode) {
+ if(authorParseNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkEndCode) {
+ var node = new Formatting.ParseNode();
+ node.AuthorNode = authorParseNode;
+ selfAndDescendantsNodes.add(node);
+ }
+ });
+ ParseTree.AdjustNodeSpanIfNeeded(astCursor, selfAndDescendantsNodes.get(0));
+ }
+ }
+ this.StartNodeSelf = ParseTree.FindStartSelfNode(selfAndDescendantsNodes, span);
+ var nodeLevel = 0;
+ var ancestorNodes = new Formatting.List_ParseNode();
+ var ancestorNodeDetails = astCursor.MoveUp();
+ if(!onlySelfAndAncestors && this.StartNodeSelf != null) {
+ if(this.StartNodeSelf.AuthorNode.Level > 0) {
+ for(var i = selfAndDescendantsNodes.count() - 1; i >= 0; --i) {
+ var sibling = selfAndDescendantsNodes.get(i).AuthorNode;
+ if(sibling.Level == this.StartNodeSelf.AuthorNode.Level && ParseTree.IsSiblingEdge(sibling.EdgeLabel) && sibling.Details.EndOffset < this.StartNodeSelf.AuthorNode.Details.StartOffset) {
+ this.StartNodePreviousSibling = sibling;
+ break;
+ }
+ }
+ } else if(this.StartNodeSelf.AuthorNode.Level == 0) {
+ parseNodeSet = astCursor.GetSubTree(2);
+ {
+ if(parseNodeSet.Count() > 0) {
+ var nodes = parseNodeSet.GetItems(0, parseNodeSet.Count());
+ var previousSibling = ParseTree.GetPreviousSibling(this.StartNodeSelf.AuthorNode, nodes);
+ if(previousSibling !== null) {
+ this.StartNodePreviousSibling = previousSibling;
+ }
+ }
+ }
+ }
+ }
+ while(ancestorNodeDetails.Kind != Formatting.AuthorParseNodeKind.apnkEmptyNode) {
+ var nodeEdge = astCursor.GetEdgeLabel();
+ var node = new Formatting.ParseNode();
+ node.AuthorNode = new Formatting.AuthorParseNode();
+ node.AuthorNode.Details = ancestorNodeDetails;
+ node.AuthorNode.Level = --nodeLevel;
+ node.AuthorNode.EdgeLabel = nodeEdge;
+ ParseTree.AdjustNodeSpanIfNeeded(astCursor, node);
+ ancestorNodes.add(node);
+ ancestorNodeDetails = astCursor.MoveUp();
+ }
+ for(var i = 0; i < ancestorNodes.count(); i++) {
+ selfAndDescendantsNodes.insert(0, ancestorNodes.get(i));
+ }
+ this.Root = ParseTree.BuildTree(selfAndDescendantsNodes);
+ }
+ };
+ ParseTree.GetPreviousSibling = function GetPreviousSibling(startNodeSelf, nodes) {
+ var previousSibling = null;
+ var siblingLevel = -1;
+ var i = nodes.length - 1;
+ for(; i > 0; i--) {
+ if(nodes[i].Details.Equals(startNodeSelf.Details)) {
+ siblingLevel = nodes[i].Level;
+ break;
+ }
+ }
+ for(; i > 0; i--) {
+ var node = nodes[i];
+ if(node.Level == siblingLevel && ParseTree.IsSiblingEdge(node.EdgeLabel) && node.Details.EndOffset < startNodeSelf.Details.StartOffset) {
+ previousSibling = node;
+ break;
+ }
+ }
+ return previousSibling;
+ };
+ ParseTree.FindStartSelfNode = function FindStartSelfNode(selfAndDescendantsNodes, span) {
+ var candidateNodes = selfAndDescendantsNodes.Where(function (node) {
+ return node.AuthorNode.Details.StartOffset >= span.start() && node.AuthorNode.Details.StartOffset < span.end();
+ });
+ if(candidateNodes.count() == 0) {
+ return Formatting.FirstOrDefault(selfAndDescendantsNodes, function () {
+ return true;
+ });
+ }
+ return candidateNodes.get(0);
+ };
+ ParseTree.IsSiblingEdge = function IsSiblingEdge(edge) {
+ return edge == Formatting.AuthorParseNodeEdge.apneArgument || edge == Formatting.AuthorParseNodeEdge.apneListItem || edge == Formatting.AuthorParseNodeEdge.apneMember;
+ };
+ ParseTree.BuildTree = function BuildTree(parseNodes) {
+ var nodesEnumerator = parseNodes.GetEnumerator();
+ if(!nodesEnumerator.MoveNext()) {
+ return null;
+ }
+ var root = nodesEnumerator.Current();
+ var lastNode = root;
+ lastNode.Parent = null;
+ var lastLevel = lastNode.AuthorNode.Level;
+ while(nodesEnumerator.MoveNext()) {
+ var currentNode = nodesEnumerator.Current();
+ if(currentNode.AuthorNode.Level == lastLevel) {
+ currentNode.Parent = lastNode.Parent;
+ lastNode.Parent.addChildNode(currentNode);
+ lastNode = currentNode;
+ } else if(currentNode.AuthorNode.Level > lastLevel) {
+ currentNode.Parent = lastNode;
+ lastNode.addChildNode(currentNode);
+ lastNode = currentNode;
+ lastLevel = currentNode.AuthorNode.Level;
+ } else {
+ while(lastLevel > currentNode.AuthorNode.Level) {
+ lastNode = lastNode.Parent;
+ lastLevel--;
+ }
+ currentNode.Parent = lastNode.Parent;
+ lastNode.Parent.addChildNode(currentNode);
+ lastNode = currentNode;
+ }
+ }
+ return root;
+ };
+ ParseTree.DumpTree = function DumpTree(logger, parseNode) {
+ if(logger.information()) {
+ var text = "";
+ for(var i = -2; i <= parseNode.AuthorNode.Level; i++) {
+ text += " ";
+ }
+ text += parseNode.toString();
+ logger.log(text);
+ Formatting.ParseNodeExtensions.GetChildren(parseNode).foreach(function (child) {
+ ParseTree.DumpTree(logger, child);
+ });
+ }
+ };
+ ParseTree.AdjustNodeSpanIfNeeded = function AdjustNodeSpanIfNeeded(astCursor, node) {
+ var propertyToGetStart = null;
+ var propertyToGetEnd = null;
+ var authorParseNode = node.AuthorNode;
+ if(authorParseNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkObject) {
+ propertyToGetStart = Formatting.AuthorParseNodeProperty.apnpLCurlyMin;
+ propertyToGetEnd = Formatting.AuthorParseNodeProperty.apnpRCurlyMin;
+ } else if(authorParseNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkArray) {
+ propertyToGetStart = Formatting.AuthorParseNodeProperty.apnpLBrackMin;
+ propertyToGetEnd = Formatting.AuthorParseNodeProperty.apnpRBrackMin;
+ } else if(authorParseNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl) {
+ propertyToGetStart = Formatting.AuthorParseNodeProperty.apnpFunctionKeywordMin;
+ propertyToGetEnd = Formatting.AuthorParseNodeProperty.apnpRCurlyMin;
+ }
+ if(propertyToGetStart != null && propertyToGetEnd != null) {
+ var newStartOffset = astCursor.GetNodeProperty(propertyToGetStart);
+ if(newStartOffset == 0) {
+ newStartOffset = node.AuthorNode.Details.StartOffset;
+ }
+ var newEndOffset = astCursor.GetNodeProperty(propertyToGetEnd);
+ if(newEndOffset == 0) {
+ newEndOffset = node.AuthorNode.Details.EndOffset;
+ } else {
+ newEndOffset += 1;
+ }
+ Formatting.ParseNodeExtensions.SetNodeSpan(node, newStartOffset, newEndOffset);
+ }
+ };
+ return ParseTree;
+ })();
+ Formatting.ParseTree = ParseTree;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var Rule = (function () {
+ function Rule(Descriptor, Operation, Flag) {
+ if (typeof Flag === "undefined") { Flag = Formatting.RuleFlags.None; }
+ this.Descriptor = Descriptor;
+ this.Operation = Operation;
+ this.Flag = Flag;
+ }
+ Rule.prototype.toString = function () {
+ return "[desc=" + this.Descriptor + "," + "operation=" + this.Operation + "," + "flag=" + this.Flag + "]";
+ };
+ return Rule;
+ })();
+ Formatting.Rule = Rule;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ (function (RuleAction) {
+ RuleAction._map = [];
+ RuleAction._map[0] = "Ignore";
+ RuleAction.Ignore = 0;
+ RuleAction._map[1] = "Space";
+ RuleAction.Space = 1;
+ RuleAction._map[2] = "NewLine";
+ RuleAction.NewLine = 2;
+ RuleAction._map[3] = "Delete";
+ RuleAction.Delete = 3;
+ })(Formatting.RuleAction || (Formatting.RuleAction = {}));
+ var RuleAction = Formatting.RuleAction;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var RuleDescriptor = (function () {
+ function RuleDescriptor(LeftTokenRange, RightTokenRange) {
+ this.LeftTokenRange = LeftTokenRange;
+ this.RightTokenRange = RightTokenRange;
+ }
+ RuleDescriptor.prototype.toString = function () {
+ return "[leftRange=" + this.LeftTokenRange + "," + "rightRange=" + this.RightTokenRange + "]";
+ };
+ RuleDescriptor.create1 = function create1(left, right) {
+ return RuleDescriptor.create4(Formatting.Shared.TokenRange.FromToken(left), Formatting.Shared.TokenRange.FromToken(right));
+ };
+ RuleDescriptor.create2 = function create2(left, right) {
+ return RuleDescriptor.create4(left, Formatting.Shared.TokenRange.FromToken(right));
+ };
+ RuleDescriptor.create3 = function create3(left, right) {
+ return RuleDescriptor.create4(Formatting.Shared.TokenRange.FromToken(left), right);
+ };
+ RuleDescriptor.create4 = function create4(left, right) {
+ return new RuleDescriptor(left, right);
+ };
+ return RuleDescriptor;
+ })();
+ Formatting.RuleDescriptor = RuleDescriptor;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ (function (RuleFlags) {
+ RuleFlags._map = [];
+ RuleFlags._map[0] = "None";
+ RuleFlags.None = 0;
+ RuleFlags._map[1] = "CanDeleteNewLines";
+ RuleFlags.CanDeleteNewLines = 1;
+ })(Formatting.RuleFlags || (Formatting.RuleFlags = {}));
+ var RuleFlags = Formatting.RuleFlags;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var RuleOperation = (function () {
+ function RuleOperation() {
+ this.Context = null;
+ this.Action = null;
+ }
+ RuleOperation.prototype.toString = function () {
+ return "[context=" + this.Context + "," + "action=" + this.Action + "]";
+ };
+ RuleOperation.create1 = function create1(action) {
+ return RuleOperation.create2(Formatting.RuleOperationContext.Any, action);
+ };
+ RuleOperation.create2 = function create2(context, action) {
+ var result = new RuleOperation();
+ result.Context = context;
+ result.Action = action;
+ return result;
+ };
+ return RuleOperation;
+ })();
+ Formatting.RuleOperation = RuleOperation;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var RuleOperationContext = (function () {
+ function RuleOperationContext() {
+ var funcs = [];
+ for (var _i = 0; _i < (arguments.length - 0); _i++) {
+ funcs[_i] = arguments[_i + 0];
+ }
+ this.customContextChecks = funcs;
+ }
+ RuleOperationContext.Any = new RuleOperationContext();
+ RuleOperationContext.prototype.IsAny = function () {
+ {
+ return this == RuleOperationContext.Any;
+ }
+ };
+ RuleOperationContext.prototype.InContext = function (context) {
+ if(this.IsAny()) {
+ return true;
+ }
+ for(var i = 0, len = this.customContextChecks.length; i < len; i++) {
+ if(!this.customContextChecks[i](context)) {
+ return false;
+ }
+ }
+ return true;
+ };
+ return RuleOperationContext;
+ })();
+ Formatting.RuleOperationContext = RuleOperationContext;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var Rules = (function () {
+ function Rules() {
+ this.IgnoreBeforeComment = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkComment), Formatting.RuleOperation.create1(Formatting.RuleAction.Ignore));
+ this.IgnoreAfterLineComment = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkComment, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFirstTokenLineCommentContext), Formatting.RuleAction.Ignore));
+ this.NoSpaceBeforeSemicolon = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkSColon), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotForContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeColon = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkColon), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeQMark = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkQMark), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterColon = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkColon, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterQMark = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkQMark, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterSemicolon = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkSColon, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NewLineAfterCloseCurly = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkRCurly, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsMultilineChildParentContext), Formatting.RuleAction.NewLine));
+ this.SpaceAfterCloseCurly = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkRCurly, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineSiblingNodeContext), Formatting.RuleAction.Space));
+ this.SpaceBetweenCloseCurlyAndElse = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkRCurly, Formatting.AuthorTokenKind.atkElse), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.SpaceBetweenCloseCurlyAndWhile = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkRCurly, Formatting.AuthorTokenKind.atkWhile), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NoSpaceBeforeDot = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkDot), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterDot = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkDot, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeOpenBracket = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkLBrack), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterOpenBracket = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkLBrack, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeCloseBracket = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkRBrack), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterCloseBracket = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkRBrack, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterOpenCurly = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkLCurly, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), Formatting.RuleAction.Space));
+ this.SpaceBeforeCloseCurly = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkRCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), Formatting.RuleAction.Space));
+ this.NoSpaceBetweenEmptyCurlyBrackets = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkLCurly, Formatting.AuthorTokenKind.atkRCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsObjectContext), Formatting.RuleAction.Delete));
+ this.NewLineAfterOpenCurlyInBlockContext = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkLCurly, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsMultilineBlockContext), Formatting.RuleAction.NewLine));
+ this.NewLineBeforeCloseCurlyInFunctionOrControl = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkRCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsMultilineBlockContext), Formatting.RuleAction.NewLine));
+ this.NoSpaceAfterUnaryPrefixOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.UnaryPrefixOperators, Formatting.Shared.TokenRange.UnaryPrefixExpressions), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterUnaryPreincrementOperator = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkInc, Formatting.Shared.TokenRange.UnaryPreincrementExpressions), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterUnaryPredecrementOperator = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkDec, Formatting.Shared.TokenRange.UnaryPredecrementExpressions), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeUnaryPostincrementOperator = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.UnaryPostincrementExpressions, Formatting.AuthorTokenKind.atkInc), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeUnaryPostdecrementOperator = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.UnaryPostdecrementExpressions, Formatting.AuthorTokenKind.atkDec), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterPostincrementWhenFollowedByAdd = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkInc, Formatting.AuthorTokenKind.atkAdd), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterAddWhenFollowedByUnaryPlus = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkAdd, Formatting.AuthorTokenKind.atkAdd), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterAddWhenFollowedByPreincrement = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkAdd, Formatting.AuthorTokenKind.atkInc), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterPostdecrementWhenFollowedBySubtract = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkDec, Formatting.AuthorTokenKind.atkSub), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterSubtractWhenFollowedByUnaryMinus = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkSub, Formatting.AuthorTokenKind.atkSub), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterSubtractWhenFollowedByPredecrement = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkSub, Formatting.AuthorTokenKind.atkDec), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.NoSpaceBeforeComma = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkComma), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterCertainKeywords = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkVar,
+ Formatting.AuthorTokenKind.atkThrow,
+ Formatting.AuthorTokenKind.atkNew,
+ Formatting.AuthorTokenKind.atkDelete,
+ Formatting.AuthorTokenKind.atkReturn,
+ Formatting.AuthorTokenKind.atkVoid,
+ Formatting.AuthorTokenKind.atkTypeof
+ ]), Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NoSpaceBeforeOpenParenInFuncCall = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionCallOrNewContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterFunctionInFuncDecl = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkFunction, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFunctionDeclContext), Formatting.RuleAction.Space));
+ this.NoSpaceBeforeOpenParenInFuncDecl = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionOrGetSetDeclContext), Formatting.RuleAction.Delete));
+ this.SpaceBetweenStatements = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkDo,
+ Formatting.AuthorTokenKind.atkElse,
+ Formatting.AuthorTokenKind.atkCase
+ ]), Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotForContext), Formatting.RuleAction.Space));
+ this.SpaceAfterTryFinally = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkTry,
+ Formatting.AuthorTokenKind.atkFinally
+ ]), Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.SpaceAfterGetSetInMember = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkIdentifier, Formatting.AuthorTokenKind.atkIdentifier), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsGetSetMemberContext), Formatting.RuleAction.Space));
+ this.SpaceBeforeBinaryKeywordOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.Any, Formatting.Shared.TokenRange.BinaryKeywordOperators), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterBinaryKeywordOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.BinaryKeywordOperators, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterConstructor = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkConstructor, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterModuleImport = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkModule, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterCertainTypeScriptKeywords = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkClass,
+ Formatting.AuthorTokenKind.atkDeclare,
+ Formatting.AuthorTokenKind.atkEnum,
+ Formatting.AuthorTokenKind.atkExport,
+ Formatting.AuthorTokenKind.atkExtends,
+ Formatting.AuthorTokenKind.atkGet,
+ Formatting.AuthorTokenKind.atkImplements,
+ Formatting.AuthorTokenKind.atkImport,
+ Formatting.AuthorTokenKind.atkInterface,
+ Formatting.AuthorTokenKind.atkModule,
+ Formatting.AuthorTokenKind.atkPrivate,
+ Formatting.AuthorTokenKind.atkPublic,
+ Formatting.AuthorTokenKind.atkSet,
+ Formatting.AuthorTokenKind.atkStatic
+ ]), Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.SpaceBeforeCertainTypeScriptKeywords = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.Any, Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkExtends,
+ Formatting.AuthorTokenKind.atkImplements
+ ])), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.SpaceAfterModuleName = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkString, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsModuleDeclContext), Formatting.RuleAction.Space));
+ this.SpaceAfterArrow = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkArrow, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterEllipsis = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkEllipsis, Formatting.AuthorTokenKind.atkIdentifier), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterOptionalParameters = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkQMark, Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkComma
+ ])), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBetweenEmptyInterfaceCurlyBrackets = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkLCurly, Formatting.AuthorTokenKind.atkRCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsInterfaceContext), Formatting.RuleAction.Delete));
+ this.HighPriorityCommonRules = [
+ this.IgnoreBeforeComment,
+ this.IgnoreAfterLineComment,
+ this.NoSpaceBeforeSemicolon,
+ this.NoSpaceBeforeColon,
+ this.SpaceAfterColon,
+ this.NoSpaceBeforeQMark,
+ this.SpaceAfterQMark,
+ this.NewLineAfterCloseCurly,
+ this.NoSpaceBeforeDot,
+ this.NoSpaceAfterDot,
+ this.NoSpaceAfterUnaryPrefixOperator,
+ this.NoSpaceAfterUnaryPreincrementOperator,
+ this.NoSpaceAfterUnaryPredecrementOperator,
+ this.NoSpaceBeforeUnaryPostincrementOperator,
+ this.NoSpaceBeforeUnaryPostdecrementOperator,
+ this.SpaceAfterPostincrementWhenFollowedByAdd,
+ this.SpaceAfterAddWhenFollowedByUnaryPlus,
+ this.SpaceAfterAddWhenFollowedByPreincrement,
+ this.SpaceAfterPostdecrementWhenFollowedBySubtract,
+ this.SpaceAfterSubtractWhenFollowedByUnaryMinus,
+ this.SpaceAfterSubtractWhenFollowedByPredecrement,
+ this.SpaceAfterOpenCurly,
+ this.SpaceBeforeCloseCurly,
+ this.SpaceAfterCloseCurly,
+ this.SpaceBetweenCloseCurlyAndElse,
+ this.SpaceBetweenCloseCurlyAndWhile,
+ this.NoSpaceBetweenEmptyCurlyBrackets,
+ this.NewLineBeforeCloseCurlyInFunctionOrControl,
+ this.SpaceAfterFunctionInFuncDecl,
+ this.NewLineAfterOpenCurlyInBlockContext,
+ this.SpaceAfterGetSetInMember,
+ this.SpaceAfterCertainKeywords,
+ this.NoSpaceBeforeOpenParenInFuncCall,
+ this.SpaceBeforeBinaryKeywordOperator,
+ this.SpaceAfterBinaryKeywordOperator,
+ this.NoSpaceAfterConstructor,
+ this.NoSpaceAfterModuleImport,
+ this.SpaceAfterCertainTypeScriptKeywords,
+ this.SpaceBeforeCertainTypeScriptKeywords,
+ this.SpaceAfterModuleName,
+ this.SpaceAfterArrow,
+ this.NoSpaceAfterEllipsis,
+ this.NoSpaceAfterOptionalParameters,
+ this.NoSpaceBetweenEmptyInterfaceCurlyBrackets,
+
+ ];
+ this.LowPriorityCommonRules = [
+ this.NoSpaceBeforeComma,
+ this.NoSpaceBeforeOpenBracket,
+ this.NoSpaceAfterOpenBracket,
+ this.NoSpaceBeforeCloseBracket,
+ this.NoSpaceAfterCloseBracket,
+ this.SpaceAfterSemicolon,
+ this.NoSpaceBeforeOpenParenInFuncDecl,
+ this.SpaceBetweenStatements,
+ this.SpaceAfterTryFinally
+ ];
+ this.SpaceAfterComma = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkComma, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterComma = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkComma, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceBeforeBinaryOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.Any, Formatting.Shared.TokenRange.BinaryOperators), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.SpaceAfterBinaryOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.BinaryOperators, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Space));
+ this.NoSpaceBeforeBinaryOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.Any, Formatting.Shared.TokenRange.BinaryOperators), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterBinaryOperator = new Formatting.Rule(Formatting.RuleDescriptor.create4(Formatting.Shared.TokenRange.BinaryOperators, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterKeywordInControl = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Keywords, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsControlDeclContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterKeywordInControl = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Keywords, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsControlDeclContext), Formatting.RuleAction.Delete));
+ this.FunctionOpenCurlyLeftTokenRange = Formatting.Shared.TokenRange.Any;
+ this.FunctionOpenCurlyLeftTokenRange_Js = Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkComment
+ ]);
+ this.SpaceBeforeOpenCurlyInFunction = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.FunctionOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrMultilineBlockContext), Formatting.RuleAction.Space), Formatting.RuleFlags.CanDeleteNewLines);
+ this.NewLineBeforeOpenCurlyInFunction = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.FunctionOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsMultilineBlockContext), Formatting.RuleAction.NewLine), Formatting.RuleFlags.CanDeleteNewLines);
+ this.TypeScriptOpenCurlyLeftTokenRange = Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkComment
+ ]);
+ this.SpaceBeforeOpenCurlyInTypeScriptDeclWithBlock = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.TypeScriptOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrMultilineBlockContext), Formatting.RuleAction.Space), Formatting.RuleFlags.CanDeleteNewLines);
+ this.NewLineBeforeOpenCurlyInTypeScriptDeclWithBlock = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.TypeScriptOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsMultilineBlockContext), Formatting.RuleAction.NewLine), Formatting.RuleFlags.CanDeleteNewLines);
+ this.ControlOpenCurlyLeftTokenRange = Formatting.Shared.TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkComment,
+ Formatting.AuthorTokenKind.atkDo,
+ Formatting.AuthorTokenKind.atkTry,
+ Formatting.AuthorTokenKind.atkFinally,
+ Formatting.AuthorTokenKind.atkElse
+ ]);
+ this.SpaceBeforeOpenCurlyInControl = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.ControlOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrMultilineBlockContext), Formatting.RuleAction.Space), Formatting.RuleFlags.CanDeleteNewLines);
+ this.NewLineBeforeOpenCurlyInControl = new Formatting.Rule(Formatting.RuleDescriptor.create2(this.ControlOpenCurlyLeftTokenRange, Formatting.AuthorTokenKind.atkLCurly), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsMultilineBlockContext), Formatting.RuleAction.NewLine), Formatting.RuleFlags.CanDeleteNewLines);
+ this.SpaceAfterSemicolonInFor = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkSColon, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsForContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterSemicolonInFor = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkSColon, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsForContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterOpenParen = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkLParen, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.SpaceBeforeCloseParen = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkRParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Space));
+ this.NoSpaceBetweenParens = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkLParen, Formatting.AuthorTokenKind.atkRParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceAfterOpenParen = new Formatting.Rule(Formatting.RuleDescriptor.create3(Formatting.AuthorTokenKind.atkLParen, Formatting.Shared.TokenRange.Any), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.NoSpaceBeforeCloseParen = new Formatting.Rule(Formatting.RuleDescriptor.create2(Formatting.Shared.TokenRange.Any, Formatting.AuthorTokenKind.atkRParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsSameLineTokenContext), Formatting.RuleAction.Delete));
+ this.SpaceAfterAnonymousFunctionKeyword = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkFunction, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFunctionDeclContext), Formatting.RuleAction.Space));
+ this.NoSpaceAfterAnonymousFunctionKeyword = new Formatting.Rule(Formatting.RuleDescriptor.create1(Formatting.AuthorTokenKind.atkFunction, Formatting.AuthorTokenKind.atkLParen), Formatting.RuleOperation.create2(new Formatting.RuleOperationContext(Rules.IsFunctionDeclContext), Formatting.RuleAction.Delete));
+ }
+ Rules.prototype.getRuleName = function (rule) {
+ var o = this;
+ for(var name in o) {
+ if(o[name] === rule) {
+ return name;
+ }
+ }
+ throw new Error("Unknown rule");
+ };
+ Rules.IsForContext = function IsForContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFor;
+ };
+ Rules.IsNotForContext = function IsNotForContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind != Formatting.AuthorParseNodeKind.apnkFor;
+ };
+ Rules.IsBinaryOpContext = function IsBinaryOpContext(context) {
+ if(context.contextNode.AuthorNode.Details.ast != null) {
+ switch(context.contextNode.AuthorNode.Details.ast.nodeType) {
+ case TypeScript.NodeType.ImportDeclaration:
+ return true;
+ }
+ }
+ switch(context.contextNode.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkAdd:
+ case Formatting.AuthorParseNodeKind.apnkSub:
+ case Formatting.AuthorParseNodeKind.apnkMul:
+ case Formatting.AuthorParseNodeKind.apnkDiv:
+ case Formatting.AuthorParseNodeKind.apnkMod:
+ case Formatting.AuthorParseNodeKind.apnkOr:
+ case Formatting.AuthorParseNodeKind.apnkXor:
+ case Formatting.AuthorParseNodeKind.apnkAnd:
+ case Formatting.AuthorParseNodeKind.apnkEq:
+ case Formatting.AuthorParseNodeKind.apnkNe:
+ case Formatting.AuthorParseNodeKind.apnkLt:
+ case Formatting.AuthorParseNodeKind.apnkLe:
+ case Formatting.AuthorParseNodeKind.apnkGe:
+ case Formatting.AuthorParseNodeKind.apnkGt:
+ case Formatting.AuthorParseNodeKind.apnkAsg:
+ case Formatting.AuthorParseNodeKind.apnkInstOf:
+ case Formatting.AuthorParseNodeKind.apnkIn:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkEqv:
+ case Formatting.AuthorParseNodeKind.apnkNEqv:
+ case Formatting.AuthorParseNodeKind.apnkLogOr:
+ case Formatting.AuthorParseNodeKind.apnkLogAnd:
+ case Formatting.AuthorParseNodeKind.apnkLsh:
+ case Formatting.AuthorParseNodeKind.apnkRsh:
+ case Formatting.AuthorParseNodeKind.apnkRs2:
+ case Formatting.AuthorParseNodeKind.apnkQmark:
+ case Formatting.AuthorParseNodeKind.apnkAsgAdd:
+ case Formatting.AuthorParseNodeKind.apnkAsgSub:
+ case Formatting.AuthorParseNodeKind.apnkAsgMul:
+ case Formatting.AuthorParseNodeKind.apnkAsgDiv:
+ case Formatting.AuthorParseNodeKind.apnkAsgMod:
+ case Formatting.AuthorParseNodeKind.apnkAsgAnd:
+ case Formatting.AuthorParseNodeKind.apnkAsgXor:
+ case Formatting.AuthorParseNodeKind.apnkAsgOr:
+ case Formatting.AuthorParseNodeKind.apnkAsgLsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRs2:
+ return true;
+ case Formatting.AuthorParseNodeKind.apnkVarDecl:
+ var varOrArgDecl = context.contextNode.AuthorNode.Details.ast;
+ var tokenSpan = null;
+ if(context.tokenSpan.tokenID === TypeScript.TokenID.Question) {
+ tokenSpan = context.tokenSpan.Span.span;
+ } else if(context.nextTokenSpan.tokenID === TypeScript.TokenID.Question) {
+ tokenSpan = context.nextTokenSpan.Span.span;
+ }
+ if(context.tokenSpan.tokenID === TypeScript.TokenID.Colon) {
+ tokenSpan = context.tokenSpan.Span.span;
+ } else if(context.nextTokenSpan.tokenID === TypeScript.TokenID.Colon) {
+ tokenSpan = context.nextTokenSpan.Span.span;
+ }
+ if(tokenSpan != null) {
+ if(varOrArgDecl != null && (varOrArgDecl.nodeType === TypeScript.NodeType.VarDecl || varOrArgDecl.nodeType === TypeScript.NodeType.ArgDecl)) {
+ if(TypeScript.isValidAstNode(varOrArgDecl)) {
+ if(!TypeScript.isValidAstNode(varOrArgDecl.init)) {
+ return false;
+ }
+ var initSpan = Formatting.Span.FromBounds(varOrArgDecl.init.minChar, varOrArgDecl.init.limChar);
+ return initSpan.Contains(tokenSpan);
+ }
+ }
+ }
+ return true;
+ case Formatting.AuthorParseNodeKind.apnkFncDecl:
+ var fncDecl = context.contextNode.AuthorNode.Details.ast;
+ if(context.tokenSpan.tokenID === TypeScript.TokenID.EqualsGreaterThan || context.nextTokenSpan.tokenID === TypeScript.TokenID.EqualsGreaterThan) {
+ if(fncDecl != null && TypeScript.hasFlag(fncDecl.fncFlags, TypeScript.FncFlags.IsFunctionExpression)) {
+ return true;
+ }
+ }
+ break;
+ default:
+ return false;
+ }
+ };
+ Rules.IsNotBinaryOpContext = function IsNotBinaryOpContext(context) {
+ return !Rules.IsBinaryOpContext(context);
+ };
+ Rules.IsBlockContext = function IsBlockContext(node) {
+ if(Rules.IsTypeScriptDeclWithBlockContextNode(node)) {
+ return true;
+ }
+ switch(node.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkBlock:
+ case Formatting.AuthorParseNodeKind.apnkList:
+ case Formatting.AuthorParseNodeKind.apnkObject:
+ case Formatting.AuthorParseNodeKind.apnkFncDecl:
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ case Formatting.AuthorParseNodeKind.apnkIf:
+ case Formatting.AuthorParseNodeKind.apnkWhile:
+ case Formatting.AuthorParseNodeKind.apnkDoWhile:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkWith:
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ case Formatting.AuthorParseNodeKind.apnkTryCatch:
+ case Formatting.AuthorParseNodeKind.apnkCatch:
+ case Formatting.AuthorParseNodeKind.apnkTry:
+ case Formatting.AuthorParseNodeKind.apnkFinally:
+ case Formatting.AuthorParseNodeKind.apnkTryFinally:
+ return true;
+ default:
+ return false;
+ }
+ };
+ Rules.IsTypeScriptDeclWithBlockContextNode = function IsTypeScriptDeclWithBlockContextNode(node) {
+ switch(node.AuthorNode.Details.nodeType) {
+ case TypeScript.NodeType.ModuleDeclaration:
+ case TypeScript.NodeType.InterfaceDeclaration:
+ case TypeScript.NodeType.ClassDeclaration:
+ return true;
+ default:
+ return false;
+ }
+ };
+ Rules.IsSingleLineBlockContext = function IsSingleLineBlockContext(context) {
+ if(!Rules.IsBlockContext(context.contextNode)) {
+ return false;
+ }
+ return context.ContextNodeAllOnSameLine();
+ };
+ Rules.IsMultilineBlockContext = function IsMultilineBlockContext(context) {
+ if(!Rules.IsBlockContext(context.contextNode)) {
+ return false;
+ }
+ return !context.ContextNodeAllOnSameLine();
+ };
+ Rules.IsFunctionDeclContext = function IsFunctionDeclContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkFncDecl;
+ };
+ Rules.IsTypeScriptDeclWithBlockContext = function IsTypeScriptDeclWithBlockContext(context) {
+ return Rules.IsTypeScriptDeclWithBlockContextNode(context.contextNode);
+ };
+ Rules.IsControlDeclContext = function IsControlDeclContext(context) {
+ switch(context.contextNode.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ case Formatting.AuthorParseNodeKind.apnkIf:
+ case Formatting.AuthorParseNodeKind.apnkWhile:
+ case Formatting.AuthorParseNodeKind.apnkDoWhile:
+ case Formatting.AuthorParseNodeKind.apnkForIn:
+ case Formatting.AuthorParseNodeKind.apnkWith:
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ case Formatting.AuthorParseNodeKind.apnkTryCatch:
+ case Formatting.AuthorParseNodeKind.apnkCatch:
+ case Formatting.AuthorParseNodeKind.apnkTry:
+ case Formatting.AuthorParseNodeKind.apnkFinally:
+ case Formatting.AuthorParseNodeKind.apnkTryFinally:
+ return true;
+ default:
+ return false;
+ }
+ };
+ Rules.IsObjectContext = function IsObjectContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkObject;
+ };
+ Rules.IsFunctionCallContext = function IsFunctionCallContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkCall;
+ };
+ Rules.IsNewContext = function IsNewContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkNew;
+ };
+ Rules.IsFunctionCallOrNewContext = function IsFunctionCallOrNewContext(context) {
+ return Rules.IsFunctionCallContext(context) || Rules.IsNewContext(context);
+ };
+ Rules.IsSameLineTokenContext = function IsSameLineTokenContext(context) {
+ return context.TokensAreOnSameLine();
+ };
+ Rules.IsSameLineSiblingNodeContext = function IsSameLineSiblingNodeContext(context) {
+ return context.TokensAreSiblingNodesOnSameLine();
+ };
+ Rules.IsMultilineChildParentContext = function IsMultilineChildParentContext(context) {
+ var parent = context.contextNode.Parent;
+ if(parent == null) {
+ return false;
+ }
+ return parent.AuthorNode.Details.EndOffset == context.nextTokenSpan.Span.startPosition() && Rules.IsMultilineBlockContext(context);
+ };
+ Rules.IsNotFormatOnEnter = function IsNotFormatOnEnter(context) {
+ return context.formattingRequestKind != Formatting.FormattingRequestKind.FormatOnEnter;
+ };
+ Rules.IsSameLineTokenOrMultilineBlockContext = function IsSameLineTokenOrMultilineBlockContext(context) {
+ return context.TokensAreOnSameLine() || Rules.IsMultilineBlockContext(context);
+ };
+ Rules.IsFunctionOrGetSetDeclContext = function IsFunctionOrGetSetDeclContext(context) {
+ return Rules.IsFunctionDeclContext(context) || Rules.IsGetSetMemberContext(context);
+ };
+ Rules.IsGetSetMemberContext = function IsGetSetMemberContext(context) {
+ return context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkGetMember || context.contextNode.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkSetMember;
+ };
+ Rules.IsFirstTokenLineCommentContext = function IsFirstTokenLineCommentContext(context) {
+ var token = context.tokenSpan;
+ var twoCharSpan = token.Span.Intersection(new Formatting.Span(token.Span.startPosition(), 2));
+ return twoCharSpan != null && twoCharSpan.GetText() == "//";
+ };
+ Rules.IsModuleDeclContext = function IsModuleDeclContext(context) {
+ return context.contextNode.AuthorNode.Details.nodeType == TypeScript.NodeType.ModuleDeclaration;
+ };
+ Rules.IsInterfaceContext = function IsInterfaceContext(context) {
+ return context.contextNode.AuthorNode.Details.nodeType == TypeScript.NodeType.List && context.contextNode.Parent != null && context.contextNode.Parent.AuthorNode.Details.nodeType == TypeScript.NodeType.InterfaceDeclaration;
+ };
+ return Rules;
+ })();
+ Formatting.Rules = Rules;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var RulesMap = (function () {
+ function RulesMap() {
+ this.map = [];
+ this.mapRowLength = 0;
+ }
+ RulesMap.create = function create(rules) {
+ var result = new RulesMap();
+ result.Initialize(rules);
+ return result;
+ };
+ RulesMap.prototype.Initialize = function (rules) {
+ this.mapRowLength = Formatting.AuthorTokenKind.Length;
+ this.map = new Array(this.mapRowLength * this.mapRowLength);
+ var rulesBucketConstructionStateList = new Array(this.map.length);
+ this.FillRules(rules, rulesBucketConstructionStateList);
+ return this.map;
+ };
+ RulesMap.prototype.FillRules = function (rules, rulesBucketConstructionStateList) {
+ var _this = this;
+ rules.foreach(function (rule) {
+ _this.FillRule(rule, rulesBucketConstructionStateList);
+ });
+ };
+ RulesMap.prototype.GetRuleBucketIndex = function (row, column) {
+ var rulesBucketIndex = (row * this.mapRowLength) + column;
+ return rulesBucketIndex;
+ };
+ RulesMap.prototype.FillRule = function (rule, rulesBucketConstructionStateList) {
+ var _this = this;
+ var specificRule = rule.Descriptor.LeftTokenRange != Formatting.Shared.TokenRange.Any && rule.Descriptor.RightTokenRange != Formatting.Shared.TokenRange.Any;
+ rule.Descriptor.LeftTokenRange.GetTokens().foreach(function (left) {
+ rule.Descriptor.RightTokenRange.GetTokens().foreach(function (right) {
+ var rulesBucketIndex = _this.GetRuleBucketIndex(left, right);
+ var rulesBucket = _this.map[rulesBucketIndex];
+ if(rulesBucket == undefined) {
+ rulesBucket = _this.map[rulesBucketIndex] = new RulesBucket();
+ }
+ rulesBucket.AddRule(rule, specificRule, rulesBucketConstructionStateList, rulesBucketIndex);
+ });
+ });
+ };
+ RulesMap.prototype.GetRule = function (context) {
+ var bucketIndex = this.GetRuleBucketIndex(context.tokenSpan.Token, context.nextTokenSpan.Token);
+ var bucket = this.map[bucketIndex];
+ if(bucket != null) {
+ for(var i = 0, len = bucket.Rules().count(); i < len; i++) {
+ var rule = bucket.Rules().get(i);
+ if(rule.Operation.Context.InContext(context)) {
+ return rule;
+ }
+ }
+ }
+ return null;
+ };
+ return RulesMap;
+ })();
+ Formatting.RulesMap = RulesMap;
+ var MaskBitSize = 5;
+ var Mask = 0x1f;
+ (function (Position) {
+ Position._map = [];
+ Position.IgnoreRulesSpecific = 0;
+ Position.IgnoreRulesAny = MaskBitSize * 1;
+ Position.ContextRulesSpecific = MaskBitSize * 2;
+ Position.ContextRulesAny = MaskBitSize * 3;
+ Position.NoContextRulesSpecific = MaskBitSize * 4;
+ Position.NoContextRulesAny = MaskBitSize * 5;
+ })(Formatting.Position || (Formatting.Position = {}));
+ var Position = Formatting.Position;
+ var RulesBucketConstructionState = (function () {
+ function RulesBucketConstructionState() {
+ this.rulesInsertionIndexBitmap = 0;
+ }
+ RulesBucketConstructionState.prototype.GetInsertionIndex = function (maskPosition) {
+ var index = 0;
+ var pos = 0;
+ var indexBitmap = this.rulesInsertionIndexBitmap;
+ while(pos <= maskPosition) {
+ index += (indexBitmap & Mask);
+ indexBitmap >>= MaskBitSize;
+ pos += MaskBitSize;
+ }
+ return index;
+ };
+ RulesBucketConstructionState.prototype.IncreaseInsertionIndex = function (maskPosition) {
+ var value = (this.rulesInsertionIndexBitmap >> maskPosition) & Mask;
+ value++;
+ Formatting.Debug.Assert((value & Mask) == value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules.");
+ var temp = this.rulesInsertionIndexBitmap & ~(Mask << maskPosition);
+ temp |= value << maskPosition;
+ this.rulesInsertionIndexBitmap = temp;
+ };
+ return RulesBucketConstructionState;
+ })();
+ Formatting.RulesBucketConstructionState = RulesBucketConstructionState;
+ var RulesBucket = (function () {
+ function RulesBucket() {
+ this.rules = new Formatting.List_Rule();
+ }
+ RulesBucket.prototype.Rules = function () {
+ return this.rules;
+ };
+ RulesBucket.prototype.AddRule = function (rule, specificTokens, constructionState, rulesBucketIndex) {
+ var position;
+ if(rule.Operation.Action == Formatting.RuleAction.Ignore) {
+ position = specificTokens ? Position.IgnoreRulesSpecific : Position.IgnoreRulesAny;
+ } else if(!rule.Operation.Context.IsAny()) {
+ position = specificTokens ? Position.ContextRulesSpecific : Position.ContextRulesAny;
+ } else {
+ position = specificTokens ? Position.NoContextRulesSpecific : Position.NoContextRulesAny;
+ }
+ var state = constructionState[rulesBucketIndex];
+ if(state === undefined) {
+ state = constructionState[rulesBucketIndex] = new RulesBucketConstructionState();
+ }
+ var index = state.GetInsertionIndex(position);
+ this.rules.insert(index, rule);
+ state.IncreaseInsertionIndex(position);
+ };
+ return RulesBucket;
+ })();
+ Formatting.RulesBucket = RulesBucket;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var RulesProvider = (function () {
+ function RulesProvider(logger) {
+ this.logger = logger;
+ this.globalRules = new Formatting.Rules();
+ }
+ RulesProvider.prototype.getRuleName = function (rule) {
+ return this.globalRules.getRuleName(rule);
+ };
+ RulesProvider.prototype.getRuleByName = function (name) {
+ return this.globalRules[name];
+ };
+ RulesProvider.prototype.setActiveRules = function (staticList) {
+ this.activeRules = staticList;
+ this.rulesMap = Formatting.RulesMap.create(this.activeRules);
+ };
+ RulesProvider.prototype.getActiveRules = function () {
+ return this.activeRules;
+ };
+ RulesProvider.prototype.getRulesMap = function () {
+ return this.rulesMap;
+ };
+ RulesProvider.prototype.ensureUptodate = function (options) {
+ var _this = this;
+ if(this.options == null || !Services.compareDataObjects(this.options, options)) {
+ var activeRules = TypeScript.timeFunction(this.logger, "RulesProvider: createActiveRules()", function () {
+ return _this.createActiveRules(options);
+ });
+ var rulesMap = TypeScript.timeFunction(this.logger, "RulesProvider: RulesMap.create()", function () {
+ return Formatting.RulesMap.create(activeRules);
+ });
+ this.activeRules = activeRules;
+ this.rulesMap = rulesMap;
+ this.options = options;
+ }
+ };
+ RulesProvider.prototype.createActiveRules = function (options) {
+ var rules = new Formatting.List_Rule();
+ rules.AddRange(this.globalRules.HighPriorityCommonRules);
+ if(options.InsertSpaceAfterCommaDelimiter) {
+ rules.Add(this.globalRules.SpaceAfterComma);
+ } else {
+ rules.Add(this.globalRules.NoSpaceAfterComma);
+ }
+ if(options.InsertSpaceAfterFunctionKeywordForAnonymousFunctions) {
+ rules.Add(this.globalRules.SpaceAfterAnonymousFunctionKeyword);
+ } else {
+ rules.Add(this.globalRules.NoSpaceAfterAnonymousFunctionKeyword);
+ }
+ if(options.InsertSpaceAfterKeywordsInControlFlowStatements) {
+ rules.Add(this.globalRules.SpaceAfterKeywordInControl);
+ } else {
+ rules.Add(this.globalRules.NoSpaceAfterKeywordInControl);
+ }
+ if(options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis) {
+ rules.Add(this.globalRules.SpaceAfterOpenParen);
+ rules.Add(this.globalRules.SpaceBeforeCloseParen);
+ rules.Add(this.globalRules.NoSpaceBetweenParens);
+ } else {
+ rules.Add(this.globalRules.NoSpaceAfterOpenParen);
+ rules.Add(this.globalRules.NoSpaceBeforeCloseParen);
+ rules.Add(this.globalRules.NoSpaceBetweenParens);
+ }
+ if(options.InsertSpaceAfterSemicolonInForStatements) {
+ rules.Add(this.globalRules.SpaceAfterSemicolonInFor);
+ } else {
+ rules.Add(this.globalRules.NoSpaceAfterSemicolonInFor);
+ }
+ if(options.InsertSpaceBeforeAndAfterBinaryOperators) {
+ rules.Add(this.globalRules.SpaceBeforeBinaryOperator);
+ rules.Add(this.globalRules.SpaceAfterBinaryOperator);
+ } else {
+ rules.Add(this.globalRules.NoSpaceBeforeBinaryOperator);
+ rules.Add(this.globalRules.NoSpaceAfterBinaryOperator);
+ }
+ if(options.PlaceOpenBraceOnNewLineForControlBlocks) {
+ rules.Add(this.globalRules.NewLineBeforeOpenCurlyInControl);
+ } else {
+ rules.Add(this.globalRules.SpaceBeforeOpenCurlyInControl);
+ }
+ if(options.PlaceOpenBraceOnNewLineForFunctions) {
+ rules.Add(this.globalRules.NewLineBeforeOpenCurlyInFunction);
+ rules.Add(this.globalRules.NewLineBeforeOpenCurlyInTypeScriptDeclWithBlock);
+ } else {
+ rules.Add(this.globalRules.SpaceBeforeOpenCurlyInFunction);
+ rules.Add(this.globalRules.SpaceBeforeOpenCurlyInTypeScriptDeclWithBlock);
+ }
+ rules.AddRange(this.globalRules.LowPriorityCommonRules);
+ return rules;
+ };
+ return RulesProvider;
+ })();
+ Formatting.RulesProvider = RulesProvider;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var SmartIndentManager = (function () {
+ function SmartIndentManager(scriptSyntaxAST, editorOptions) {
+ this.scriptSyntaxAST = scriptSyntaxAST;
+ this.editorOptions = editorOptions;
+ this.logger = new TypeScript.LoggerAdapter(this.scriptSyntaxAST.getLogger());
+ this.sourceText = this.scriptSyntaxAST.getSourceText();
+ this.snapshot = new Formatting.TextSnapshot(this.scriptSyntaxAST.getScript(), this.sourceText);
+ this.fileAuthoringProxy = new Formatting.FileAuthoringProxy(this.scriptSyntaxAST);
+ this.tokenKindMap = Formatting.AuthorTokenKindMap.getInstance();
+ }
+ SmartIndentManager.prototype.getSmartIndentAtLineNumber = function (lineNumber) {
+ var line = this.snapshot.GetLineFromLineNumber(lineNumber);
+ var caretPosition = new Formatting.SnapshotSpan(this.snapshot, new Formatting.Span(line.startPosition(), 0));
+ var tokensSpan = this.getPossibleTokenSpan(caretPosition);
+ var tokens = this.gtTokens(tokensSpan);
+ var languageHostIndentation = null;
+ var task = new Formatting.SmartIndentTask(this.logger, caretPosition, tokens, this.fileAuthoringProxy, this.editorOptions, languageHostIndentation);
+ task.Run();
+ if(task.DesiredIndentation === null) {
+ return this.getBlockIndent(line);
+ } else {
+ return Formatting.Indenter.GetIndentSizeFromIndentText(task.DesiredIndentation, this.editorOptions);
+ }
+ };
+ SmartIndentManager.prototype.getPossibleTokenSpan = function (caretPosition) {
+ var startPosition = caretPosition.start().GetContainingLine().startPosition();
+ var endPosition = caretPosition.start().GetContainingLine().endPosition();
+ endPosition = Formatting.Math.Min(endPosition, startPosition + 100);
+ return new Formatting.SnapshotSpan(caretPosition.snapshot, Formatting.Span.FromBounds(startPosition, endPosition));
+ };
+ SmartIndentManager.prototype.gtTokens = function (span) {
+ return Formatting.getTokensInSpan(this.logger, this.scriptSyntaxAST, this.tokenKindMap, span);
+ };
+ SmartIndentManager.prototype.getBlockIndent = function (line) {
+ var previousLine = null;
+ for(var lineNumber = line.lineNumber() - 1; lineNumber >= 0; --lineNumber) {
+ previousLine = line.snapshot().GetLineFromLineNumber(lineNumber);
+ var text = previousLine.getText();
+ if(text.length > 0) {
+ return Formatting.Indenter.GetIndentSizeFromIndentText(text, this.editorOptions);
+ }
+ }
+ return null;
+ };
+ return SmartIndentManager;
+ })();
+ Formatting.SmartIndentManager = SmartIndentManager;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var SmartIndentTask = (function () {
+ function SmartIndentTask(logger, snapshotSpan, tokens, fileAuthoringProxy, editorOptions, languageHostIndentation) {
+ this.logger = logger;
+ this.snapshotSpan = snapshotSpan;
+ this.tokens = tokens;
+ this.fileAuthoringProxy = fileAuthoringProxy;
+ this.editorOptions = editorOptions;
+ this.languageHostIndentation = languageHostIndentation;
+ this.snapshot = this.snapshotSpan.snapshot;
+ this.DesiredIndentation = null;
+ }
+ SmartIndentTask.prototype.Run = function () {
+ var _this = this;
+ var tree = TypeScript.timeFunction(this.logger, "SmartIndentTask: new ParseTree()", function () {
+ return new Formatting.ParseTree(_this.fileAuthoringProxy, _this.snapshotSpan.span, null, true);
+ });
+ if(tree.Root == null) {
+ return;
+ }
+ Formatting.IndentationEdgeFinder.FillIndentationLevels(tree.Root);
+ Formatting.ParseTree.DumpTree(this.logger, tree.Root);
+ this.FindIndentation(tree);
+ };
+ SmartIndentTask.prototype.FindIndentation = function (tree) {
+ var caretSpan = this.snapshotSpan.span;
+ var context = Formatting.ParseTree.FindCommonParentNode(caretSpan, caretSpan, tree.Root);
+ if(context && context.AuthorNode.Details.nodeType == TypeScript.NodeType.QString) {
+ var nodeSpan = Formatting.Span.FromBounds(context.AuthorNode.Details.StartOffset, context.AuthorNode.Details.EndOffset);
+ if(nodeSpan.Contains(caretSpan)) {
+ this.DesiredIndentation = "";
+ return;
+ }
+ }
+ while(context != null && context.AuthorNode.Details.StartOffset == caretSpan.start() && !(context.AuthorNode.Details.Kind == Formatting.AuthorParseNodeKind.apnkBlock && context.AuthorNode.Details.Flags != Formatting.AuthorParseNodeFlags.apnfSyntheticNode)) {
+ context = context.Parent;
+ }
+ if(context == null) {
+ return;
+ }
+ var firstToken = Formatting.FirstOrDefault(this.tokens, function (item) {
+ return true;
+ });
+ if(firstToken == null) {
+ firstToken = new Formatting.TokenSpan(Formatting.AuthorTokenKind.atkSColon, TypeScript.TokenID.Semicolon, this.snapshotSpan);
+ } else if(firstToken.Token != Formatting.AuthorTokenKind.atkElse && firstToken.Token != Formatting.AuthorTokenKind.atkWhile && firstToken.Token != Formatting.AuthorTokenKind.atkLCurly && firstToken.Token != Formatting.AuthorTokenKind.atkRCurly) {
+ firstToken = new Formatting.TokenSpan(Formatting.AuthorTokenKind.atkSColon, TypeScript.TokenID.Semicolon, this.snapshotSpan);
+ }
+ if(this.CanDoSmartIndent(context, {
+ token: firstToken
+ })) {
+ var indenter = new Formatting.Indenter(this.logger, tree, this.snapshot, this.languageHostIndentation, this.editorOptions, firstToken, true);
+ var edit = Formatting.FirstOrDefault(indenter.GetIndentationEdits(firstToken, null, context, true), function (item) {
+ return true;
+ });
+ if(edit != null) {
+ this.DesiredIndentation = edit.ReplaceWith;
+ }
+ }
+ };
+ SmartIndentTask.prototype.CanDoSmartIndent = function (context, firstToken) {
+ var node = context;
+ while(node != null && node.ChildrenIndentationDelta == null) {
+ node = node.Parent;
+ }
+ if(node == null) {
+ return false;
+ }
+ if(Formatting.Rules.IsTypeScriptDeclWithBlockContextNode(node)) {
+ return this.CanDoSmartIndentInStatementWithBlock(node, firstToken);
+ }
+ if(node.AuthorNode.Details.ast != null) {
+ switch(node.AuthorNode.Details.ast.nodeType) {
+ case TypeScript.NodeType.ImportDeclaration:
+ return this.CanDoSmartIndentInStatement(node);
+ }
+ }
+ switch(node.AuthorNode.Details.Kind) {
+ case Formatting.AuthorParseNodeKind.apnkAsg:
+ case Formatting.AuthorParseNodeKind.apnkAsgAdd:
+ case Formatting.AuthorParseNodeKind.apnkAsgSub:
+ case Formatting.AuthorParseNodeKind.apnkAsgMul:
+ case Formatting.AuthorParseNodeKind.apnkAsgDiv:
+ case Formatting.AuthorParseNodeKind.apnkAsgMod:
+ case Formatting.AuthorParseNodeKind.apnkAsgAnd:
+ case Formatting.AuthorParseNodeKind.apnkAsgXor:
+ case Formatting.AuthorParseNodeKind.apnkAsgOr:
+ case Formatting.AuthorParseNodeKind.apnkAsgLsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRsh:
+ case Formatting.AuthorParseNodeKind.apnkAsgRs2:
+ case Formatting.AuthorParseNodeKind.apnkVarDecl:
+ case Formatting.AuthorParseNodeKind.apnkVarDeclList:
+ case Formatting.AuthorParseNodeKind.apnkCall:
+ case Formatting.AuthorParseNodeKind.apnkArray:
+ case Formatting.AuthorParseNodeKind.apnkMember:
+ return this.CanDoSmartIndentInStatement(node);
+ case Formatting.AuthorParseNodeKind.apnkFor:
+ return this.CanDoSmartIndentInFor(node);
+ case Formatting.AuthorParseNodeKind.apnkFncDecl:
+ return this.CanDoSmartIndentInFunction(node, firstToken);
+ case Formatting.AuthorParseNodeKind.apnkTry:
+ case Formatting.AuthorParseNodeKind.apnkFinally:
+ return this.CanDoSmartIndentInStatementWithBlock(node, firstToken);
+ case Formatting.AuthorParseNodeKind.apnkCatch:
+ case Formatting.AuthorParseNodeKind.apnkSwitch:
+ return this.CanDoSmartIndentInStatementWithParenAndBlock(node, firstToken);
+ default:
+ return true;
+ }
+ };
+ SmartIndentTask.prototype.CanDoSmartIndentInStatement = function (node) {
+ var contextLine = this.snapshot.GetLineNumberFromPosition(node.AuthorNode.Details.StartOffset);
+ var newLine = this.snapshot.GetLineNumberFromPosition(this.snapshotSpan.startPosition());
+ return SmartIndentTask.IsEmptyRegion(this.snapshot, contextLine + 1, newLine - 1);
+ };
+ SmartIndentTask.prototype.CanDoSmartIndentInFunction = function (node, firstToken) {
+ var astCursor = this.fileAuthoringProxy.GetASTCursor();
+ {
+ astCursor.SeekToOffset(node.AuthorNode.Details.StartOffset, false);
+ var rightParenPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpRParenMin);
+ if(rightParenPos == 0 || this.snapshotSpan.startPosition() <= rightParenPos) {
+ return this.CanDoSmartIndentInStatement(node);
+ }
+ var leftCurlyPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpLCurlyMin);
+ if(leftCurlyPos == 0 || this.snapshotSpan.startPosition() <= leftCurlyPos) {
+ firstToken = {
+ token: new Formatting.TokenSpan(Formatting.AuthorTokenKind.atkLCurly, TypeScript.TokenID.OpenBrace, this.snapshotSpan)
+ };
+ }
+ return true;
+ }
+ };
+ SmartIndentTask.prototype.CanDoSmartIndentInStatementWithBlock = function (node, firstToken) {
+ var astCursor = this.fileAuthoringProxy.GetASTCursor();
+ {
+ astCursor.SeekToOffset(node.AuthorNode.Details.StartOffset, false);
+ var leftCurlyPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpLCurlyMin);
+ if(leftCurlyPos == 0 || this.snapshotSpan.startPosition() <= leftCurlyPos) {
+ firstToken = {
+ token: new Formatting.TokenSpan(Formatting.AuthorTokenKind.atkLCurly, TypeScript.TokenID.OpenBrace, this.snapshotSpan)
+ };
+ }
+ return true;
+ }
+ };
+ SmartIndentTask.prototype.CanDoSmartIndentInStatementWithParenAndBlock = function (node, firstToken) {
+ var astCursor = this.fileAuthoringProxy.GetASTCursor();
+ {
+ astCursor.SeekToOffset(node.AuthorNode.Details.StartOffset, false);
+ var rightParenPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpRParenMin);
+ var leftCurlyPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpLCurlyMin);
+ if(rightParenPos > 0 && this.snapshotSpan.startPosition() > rightParenPos && (leftCurlyPos == 0 || this.snapshotSpan.startPosition() <= leftCurlyPos)) {
+ firstToken = {
+ token: new Formatting.TokenSpan(Formatting.AuthorTokenKind.atkLCurly, TypeScript.TokenID.OpenBrace, this.snapshotSpan)
+ };
+ }
+ return true;
+ }
+ };
+ SmartIndentTask.prototype.CanDoSmartIndentInFor = function (node) {
+ var astCursor = this.fileAuthoringProxy.GetASTCursor();
+ {
+ astCursor.SeekToOffset(node.AuthorNode.Details.StartOffset, false);
+ var rightParenPos = astCursor.GetNodeProperty(Formatting.AuthorParseNodeProperty.apnpRParenMin);
+ if(rightParenPos == 0 || this.snapshotSpan.startPosition() <= rightParenPos) {
+ return this.CanDoSmartIndentInStatement(node);
+ }
+ return true;
+ }
+ };
+ SmartIndentTask.IsEmptyRegion = function IsEmptyRegion(snapshot, startLine, endLine) {
+ var empty = true;
+ var lineNum = startLine;
+ while(lineNum <= endLine) {
+ var line = snapshot.GetLineFromLineNumber(lineNum);
+ var lineText = line.getText();
+ if(!SmartIndentTask.IsEmptyString(lineText)) {
+ empty = false;
+ break;
+ }
+ lineNum++;
+ }
+ return empty;
+ };
+ SmartIndentTask.IsEmptyString = function IsEmptyString(lineText) {
+ for(var i = 0, len = lineText.length; i < len; i++) {
+ if(!Formatting.EditorUtilities.IsWhitespace(lineText.charCodeAt(i))) {
+ return false;
+ }
+ }
+ return true;
+ };
+ return SmartIndentTask;
+ })();
+ Formatting.SmartIndentTask = SmartIndentTask;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var StatementFinderTask = (function () {
+ function StatementFinderTask(logger, semicolonPoint, fileAuthoringProxy) {
+ this.logger = logger;
+ this.semicolonPoint = semicolonPoint;
+ this.fileAuthoringProxy = fileAuthoringProxy;
+ this.BlockSpan = null;
+ }
+ StatementFinderTask.prototype.Run = function () {
+ var parseCursor = this.fileAuthoringProxy.GetASTCursor();
+ {
+ var startPos = -1;
+ var node = parseCursor.SeekToOffset(this.semicolonPoint.position, true);
+ while(node && node.Kind !== Formatting.AuthorParseNodeKind.apnkEmpty && node.nodeType !== TypeScript.NodeType.List) {
+ if((node.EndOffset - 1) === this.semicolonPoint.position) {
+ startPos = node.StartOffset;
+ }
+ node = parseCursor.MoveUp();
+ }
+ if(startPos !== -1) {
+ this.BlockSpan = new Formatting.Span(startPos, this.semicolonPoint.position - startPos + 1);
+ }
+ }
+ };
+ return StatementFinderTask;
+ })();
+ Formatting.StatementFinderTask = StatementFinderTask;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var TextEditInfo = (function () {
+ function TextEditInfo(position, length, replaceWith) {
+ this.position = position;
+ this.length = length;
+ this.replaceWith = replaceWith;
+ this.Position = this.position;
+ this.Length = length;
+ this.ReplaceWith = this.replaceWith;
+ }
+ return TextEditInfo;
+ })();
+ Formatting.TextEditInfo = TextEditInfo;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ (function (Shared) {
+ var TokenRangeAccess = (function () {
+ function TokenRangeAccess(from, to, except) {
+ this.tokens = new Formatting.List_AuthorTokenKind();
+ for(var token = from; token <= to; token++) {
+ if(except.indexOf(token) < 0) {
+ this.tokens.add(token);
+ }
+ }
+ }
+ TokenRangeAccess.prototype.GetTokens = function () {
+ return this.tokens;
+ };
+ TokenRangeAccess.prototype.Contains = function (token) {
+ return this.tokens.contains(token);
+ };
+ TokenRangeAccess.prototype.toString = function () {
+ return "[tokenRangeStart=" + (Formatting.AuthorTokenKind)._map[this.tokens.get(0)] + "," + "tokenRangeEnd=" + (Formatting.AuthorTokenKind)._map[this.tokens.get(this.tokens.count() - 1)] + "]";
+ };
+ return TokenRangeAccess;
+ })();
+ Shared.TokenRangeAccess = TokenRangeAccess;
+ var TokenValuesAccess = (function () {
+ function TokenValuesAccess(tks) {
+ this.tokens = new Formatting.List_AuthorTokenKind();
+ this.tokens.addAll(tks);
+ }
+ TokenValuesAccess.prototype.GetTokens = function () {
+ return this.tokens;
+ };
+ TokenValuesAccess.prototype.Contains = function (token) {
+ return this.GetTokens().contains(token);
+ };
+ return TokenValuesAccess;
+ })();
+ Shared.TokenValuesAccess = TokenValuesAccess;
+ var TokenSingleValueAccess = (function () {
+ function TokenSingleValueAccess(token) {
+ this.token = token;
+ }
+ TokenSingleValueAccess.prototype.GetTokens = function () {
+ var result = new Formatting.List_AuthorTokenKind();
+ result.add(this.token);
+ return result;
+ };
+ TokenSingleValueAccess.prototype.Contains = function (tokenValue) {
+ return tokenValue == this.token;
+ };
+ TokenSingleValueAccess.prototype.toString = function () {
+ return "[singleTokenKind=" + (Formatting.AuthorTokenKind)._map[this.token] + "]";
+ };
+ return TokenSingleValueAccess;
+ })();
+ Shared.TokenSingleValueAccess = TokenSingleValueAccess;
+ var TokenAllAccess = (function () {
+ function TokenAllAccess() { }
+ TokenAllAccess.prototype.GetTokens = function () {
+ var result = new Formatting.List_AuthorTokenKind();
+ for(var token = Formatting.AuthorTokenKind.atkEnd; token < Formatting.AuthorTokenKind.Length; token++) {
+ result.add(token);
+ }
+ return result;
+ };
+ TokenAllAccess.prototype.Contains = function (tokenValue) {
+ return true;
+ };
+ TokenAllAccess.prototype.toString = function () {
+ return "[allTokens]";
+ };
+ return TokenAllAccess;
+ })();
+ Shared.TokenAllAccess = TokenAllAccess;
+ var TokenRange = (function () {
+ function TokenRange(tokenAccess) {
+ this.tokenAccess = tokenAccess;
+ }
+ TokenRange.FromToken = function FromToken(token) {
+ return new TokenRange(new TokenSingleValueAccess(token));
+ };
+ TokenRange.FromTokens = function FromTokens(tokens) {
+ return new TokenRange(new TokenValuesAccess(tokens));
+ };
+ TokenRange.FromRange = function FromRange(f, to, except) {
+ if (typeof except === "undefined") { except = []; }
+ return new TokenRange(new TokenRangeAccess(f, to, except));
+ };
+ TokenRange.AllTokens = function AllTokens() {
+ return new TokenRange(new TokenAllAccess());
+ };
+ TokenRange.prototype.GetTokens = function () {
+ return this.tokenAccess.GetTokens();
+ };
+ TokenRange.prototype.Contains = function (token) {
+ return this.tokenAccess.Contains(token);
+ };
+ TokenRange.prototype.toString = function () {
+ return this.tokenAccess.toString();
+ };
+ TokenRange.Any = TokenRange.AllTokens();
+ TokenRange.Keywords = TokenRange.FromRange(Formatting.AuthorTokenKind.atkBreak, Formatting.AuthorTokenKind.atkWith);
+ TokenRange.Operators = TokenRange.FromRange(Formatting.AuthorTokenKind.atkSColon, Formatting.AuthorTokenKind.atkScope);
+ TokenRange.BinaryOperators = TokenRange.FromRange(Formatting.AuthorTokenKind.atkArrow, Formatting.AuthorTokenKind.atkPct);
+ TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIn,
+ Formatting.AuthorTokenKind.atkInstanceof
+ ]);
+ TokenRange.ReservedKeywords = TokenRange.FromRange(Formatting.AuthorTokenKind.atkImplements, Formatting.AuthorTokenKind.atkYield);
+ TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkAdd,
+ Formatting.AuthorTokenKind.atkSub,
+ Formatting.AuthorTokenKind.atkTilde,
+ Formatting.AuthorTokenKind.atkBang
+ ]);
+ TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkNumber,
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkLParen,
+ Formatting.AuthorTokenKind.atkLBrack,
+ Formatting.AuthorTokenKind.atkLCurly,
+ Formatting.AuthorTokenKind.atkThis,
+ Formatting.AuthorTokenKind.atkNew
+ ]);
+ TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkLParen,
+ Formatting.AuthorTokenKind.atkThis,
+ Formatting.AuthorTokenKind.atkNew
+ ]);
+ TokenRange.UnaryPostincrementExpressions = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkRBrack,
+ Formatting.AuthorTokenKind.atkNew
+ ]);
+ TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkLParen,
+ Formatting.AuthorTokenKind.atkThis,
+ Formatting.AuthorTokenKind.atkNew
+ ]);
+ TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([
+ Formatting.AuthorTokenKind.atkIdentifier,
+ Formatting.AuthorTokenKind.atkRParen,
+ Formatting.AuthorTokenKind.atkRBrack,
+ Formatting.AuthorTokenKind.atkNew
+ ]);
+ return TokenRange;
+ })();
+ Shared.TokenRange = TokenRange;
+ })(Formatting.Shared || (Formatting.Shared = {}));
+ var Shared = Formatting.Shared;
+})(Formatting || (Formatting = {}));
+var Formatting;
+(function (Formatting) {
+ var TokenSpan = (function () {
+ function TokenSpan(Token, tokenID, Span) {
+ this.Token = Token;
+ this.tokenID = tokenID;
+ this.Span = Span;
+ this._lineNumber = null;
+ }
+ TokenSpan.prototype.lineNumber = function () {
+ if(this._lineNumber === null) {
+ this._lineNumber = this.Span.snapshot.GetLineNumberFromPosition(this.Span.startPosition());
+ }
+ return this._lineNumber;
+ };
+ TokenSpan.prototype.toString = function () {
+ var result = "[tokenKind=" + (Formatting.AuthorTokenKind)._map[this.Token] + ", " + "tokenID=" + (TypeScript.TokenID)._map[this.tokenID] + ", " + "lineNumber=" + this._lineNumber + ", " + "span=" + this.Span + "]";
+ return result;
+ };
+ return TokenSpan;
+ })();
+ Formatting.TokenSpan = TokenSpan;
+})(Formatting || (Formatting = {}));
diff --git a/src/ts/main.ts b/src/ts/main.ts
index 4826b8e..0c54e10 100644
--- a/src/ts/main.ts
+++ b/src/ts/main.ts
@@ -1,5 +1,5 @@
///
-///
+///
var readline = require('readline');
diff --git a/core/__init__.py b/ts_helpers/__init__.py
similarity index 100%
rename from core/__init__.py
rename to ts_helpers/__init__.py
diff --git a/core/install.py b/ts_helpers/install.py
similarity index 91%
rename from core/install.py
rename to ts_helpers/install.py
index 1f042ad..9d492fe 100644
--- a/core/install.py
+++ b/ts_helpers/install.py
@@ -15,7 +15,6 @@
if os.name == 'nt':
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-
if ts_settings.has("node_path"):
node_path = ts_settings.get("node_path")
def get_node_path():
@@ -25,7 +24,7 @@ def check_for_node():
node_path = get_node_path()
try:
subprocess.call([node_path, "--help"], startupinfo = startupinfo)
- except Exception, e:
+ except Exception as e:
sublime.error_message("The node executable hasn't been found, you might want to set it in your typescript settings by adding the \"node_path\" key")
raise e
@@ -52,7 +51,8 @@ def check_plugin_path():
sublime.save_settings("typescript.sublime-settings")
def needs_to_compile_plugin():
- return not path.exists(path.join(ts_settings.get("plugin_path"), "bin/main.js"))
+ mainPath = path.join(ts_settings.get("plugin_path"), "bin/main.js")
+ return not path.exists(mainPath)
def compile_plugin(plugin_path):
def plugin_file(f):
@@ -63,10 +63,10 @@ def plugin_file(f):
if len(os.listdir(typescript_dir)) == 0:
# We need to get typescript and unzip it
- import urllib
+ import urllib.request, urllib.parse, urllib.error
import zipfile
zf_path = plugin_file("lib/typescript/ts.zip")
- urllib.urlretrieve(TYPESCRIPT_SOURCE_LINK, zf_path)
+ urllib.request.urlretrieve(TYPESCRIPT_SOURCE_LINK, zf_path)
zipf = zipfile.ZipFile(zf_path)
zipf.extractall(path=plugin_file("lib/typescript/"))
zipf.close()
@@ -77,6 +77,7 @@ def plugin_file(f):
if not path.exists(bindir):
os.makedirs(bindir)
+ print("compiling main.js")
subprocess.call([get_node_path(),
plugin_file("lib/typescript/bin/tsc.js"),
plugin_file("src/ts/main.ts"),
diff --git a/core/project.py b/ts_helpers/project.py
similarity index 74%
rename from core/project.py
rename to ts_helpers/project.py
index 43cb287..d3dbf81 100644
--- a/core/project.py
+++ b/ts_helpers/project.py
@@ -6,7 +6,7 @@ def find_project_file(file_path):
while b != "":
files = os.listdir(a)
if ".sublimets" in files:
- print "FOUND project file", path.join(a, ".sublimets"), "for ts file ", file_path
+ print("FOUND project file", path.join(a, ".sublimets"), "for ts file ", file_path)
return path.join(a, ".sublimets")
a, b = path.split(a)
diff --git a/ts_helpers/stderr.log b/ts_helpers/stderr.log
new file mode 100644
index 0000000..e69de29
diff --git a/typescript.py b/typescript.py
index 2506bb1..0c757cc 100644
--- a/typescript.py
+++ b/typescript.py
@@ -10,9 +10,20 @@
from time import sleep, time
import re
import difflib
-from core import project, install
+from .ts_helpers import project, install
from itertools import cycle, chain
from collections import defaultdict
+import sys
+
+# when using st3 import reload so we can reload
+# the submodule ts_helpers whenever it changes during development
+if sublime.version() == '' or int(sublime.version()) > 3000:
+ st_version = 3
+ from imp import reload
+
+ reload(sys.modules['sublime-typescript.ts_helpers.install'])
+ reload(sys.modules['sublime-typescript.ts_helpers.project'])
+
class AtomicValue:
def __init__(self):
@@ -34,6 +45,7 @@ def dec(self):
ts_settings = sublime.load_settings("typescript.sublime-settings")
install.check_for_node()
+
do_compile = install.check_plugin_path()
plugin_path = ts_settings.get("plugin_path")
def install_helper():
@@ -41,7 +53,11 @@ def install_helper():
install.compile_plugin(plugin_path)
loading_files.dec()
thread_install = None
+
+
+
if install.needs_to_compile_plugin():
+ print("we need to install the plugin")
thread_install = Thread(target=install_helper)
thread_install.start()
@@ -94,16 +110,16 @@ def format_diffs(old_content, new_content):
if oc[0] in ['insert', 'delete', 'replace']]
prefixes = {
- "method": u"◉",
- "property": u"●",
- "class":u"◆",
- "interface":u"◇",
- "keyword":u"∆",
- "variable": u"∨",
+ "method": "◉",
+ "property": "●",
+ "class":"◆",
+ "interface":"◇",
+ "keyword":"∆",
+ "variable": "∨",
}
js_id_re = re.compile(
- ur'^[_$a-zA-Z\u00FF-\uFFFF][_$a-zA-Z0-9\u00FF-\uFFFF]*'
+ r'^[_$a-zA-Z\u00FF-\uFFFF][_$a-zA-Z0-9\u00FF-\uFFFF]*'
)
def is_member_completion(line):
@@ -115,7 +131,7 @@ def partial_completion():
return line.endswith(".") or partial_completion()
def format_completion_entry(c_entry):
- prefix = prefixes.get(c_entry["kind"], u"-")
+ prefix = prefixes.get(c_entry["kind"], "-")
prefix += " "
middle = c_entry["name"]
suffix = "\t" + c_entry["type"]
@@ -125,7 +141,7 @@ def partition_by(lst, disc):
partitions = defaultdict(list)
for el in lst:
partitions[disc(el)].append(el)
- return partitions.values()
+ return list(partitions.values())
def sort_completions(entries):
return [(format_completion_entry(item), item["name"])
@@ -163,7 +179,7 @@ def get_node_path():
class PluginInstance(object):
def __init__(self):
- print "PLUGIN_FILE ", plugin_file("bin/main.js")
+ print("PLUGIN_FILE ", plugin_file("bin/main.js"))
self.open_files = set()
self.views_text = {}
self.errors_intervals = {}
@@ -173,23 +189,25 @@ def init_async():
if thread_install:
thread_install.join()
loading_files.inc()
+ # kwargs = {"stderr":open(plugin_file('stderr.log'),'a+')}
kwargs = {}
errorlog = None
if os.name == 'nt':
- errorlog = open(os.devnull, 'w')
+ errorlog = open(os.devnull, 'a+')
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
kwargs = {"stderr":errorlog, "startupinfo":startupinfo}
- self.p = Popen([get_node_path(), plugin_file("bin/main.js")], stdin=PIPE, stdout=PIPE, **kwargs)
+ self.p = Popen([get_node_path(), plugin_file("bin/main.js")], stdin=PIPE, stdout=PIPE,cwd=get_plugin_path(), **kwargs)
if errorlog:
errorlog.close()
self.serv_add_file(plugin_file("bin/lib.d.ts"))
loading_files.dec()
- print "OUT OF INIT ASYNC"
+ print("OUT OF INIT ASYNC")
self.init_sem.release()
+
self.init_sem.acquire()
Thread(target=init_async).start()
@@ -199,10 +217,16 @@ def close_process(self):
def msg(self, *args):
res = None
message = json.dumps(args) + "\n"
- t = time()
- self.p.stdin.write(message)
+ self.p.stdin.write(bytes(message, 'utf-8'))
+ self.p.stdin.flush()
+ self.p.stdout.flush()
msg_content = self.p.stdout.readline()
- res = json.loads(msg_content)
+
+ if len(msg_content) == 0:
+ return json.loads("{}")
+
+ # print(msg_content.decode('utf-8'))
+ res = json.loads(msg_content.decode('utf-8'))
return res
def serv_add_file(self, file_name):
@@ -263,7 +287,7 @@ def update_server_code(self, filename, new_content):
self.serv_edit_file(filename, *diff)
if bydiff_content != new_content:
- print "ERROR WITH DIFF ALGORITHM"
+ print("ERROR WITH DIFF ALGORITHM")
raise Exception("ERROR WITH DIFF ALGORITHM")
else:
self.views_text[filename] = new_content
@@ -287,7 +311,7 @@ def handle_errors(self, view, ts_errors):
)
def get_error_for_pos(self, pos):
- for (l, h), error in self.errors_intervals.iteritems():
+ for (l, h), error in self.errors_intervals.items():
if pos >= l and pos <= h:
return error
return None
@@ -420,7 +444,7 @@ def get_worker_thread(self, view):
return self.workers[bid]
def on_load(self, view):
- print "IN ON LOAD FOR VIEW : ", view.file_name()
+ print("IN ON LOAD FOR VIEW : ", view.file_name())
if is_ts(view):
init_view(view)
@@ -445,7 +469,7 @@ def on_query_completions(self, view, prefix, locations):
line = view.substr(sublime.Region(view.line(pos-1).a, pos))
bword_pos = sublime.Region(view.word(pos).a, pos)
word = view.substr(bword_pos)
- print "WORD : ", word
+ print("WORD : ", word)
completions_json = get_plugin(view).serv_get_completions(
view.file_name(), bword_pos.a, is_member_completion(line)
)
diff --git a/typescript.sublime-settings b/typescript.sublime-settings
index 2589db1..abeea25 100644
--- a/typescript.sublime-settings
+++ b/typescript.sublime-settings
@@ -1,4 +1,5 @@
{
- "extensions": ["ts", "str"],
- "auto_complete": false
+ "extensions": ["ts", "str"],
+ "auto_complete": true,
+ "node_path" : "/Users/martijnlaarman/.nvm/v0.10.4/bin/node"
}