/// <reference path="binder.ts"/>

module ts {

let nextSymbolId = 1;

let nextNodeId = 1;

let nextMergeId = 1;

export function getNodeId(node: Node): number {

if (!node.id) node.id = nextNodeId++;

return node.id;

}

export function getSymbolId(symbol: Symbol): number {

if (!symbol.id) {

symbol.id = nextSymbolId++;

module ts {

// Ternary values are defined such that

// x & y is False if either x or y is False.

// x & y is Maybe if either x or y is Maybe, but neither x or y is False.

module ts {

interface ModuleElementDeclarationEmitInfo {

node: Node;

outputPos: number;

module ts {

export var Diagnostics = {

Unterminated_string_literal: { code: 1002, category: DiagnosticCategory.Error, key: "Unterminated string literal." },

module ts {

// represents one LexicalEnvironment frame to store unique generated names

interface ScopeFrame {

_n = 0x20000000, // Use/preference flag for '_n'

}

// targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature

export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFile: SourceFile): EmitResult {

// emit output for the __extends helper function

module ts {

export interface ErrorCallback {

(message: DiagnosticMessage, length: number): void;

}

export interface Scanner {

getStartPos(): number;

getToken(): SyntaxKind;

return textToToken[s];

}

export function computeLineStarts(text: string): number[] {

let result: number[] = new Array();

let pos = 0;

return computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character);

}

export function computePositionOfLineAndCharacter(lineStarts: number[], line: number, character: number): number {

Debug.assert(line >= 0 && line < lineStarts.length);

return lineStarts[line] + character;

}

export function getLineStarts(sourceFile: SourceFile): number[] {

return sourceFile.lineMap || (sourceFile.lineMap = computeLineStarts(sourceFile.text));

}

export function computeLineAndCharacterOfPosition(lineStarts: number[], position: number) {

let lineNumber = binarySearch(lineStarts, position);

if (lineNumber < 0) {

return ch >= CharacterCodes._0 && ch <= CharacterCodes._9;

}

export function isOctalDigit(ch: number): boolean {

return ch >= CharacterCodes._0 && ch <= CharacterCodes._7;

}

export function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number {

while (true) {

let ch = text.charCodeAt(pos);

ch > CharacterCodes.maxAsciiCharacter && isUnicodeIdentifierPart(ch, languageVersion);

}

export function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback): Scanner {

let pos: number; // Current position (end position of text of current token)

let len: number; // Length of text