start: number;

end: number;

name: string;

const activeRanges: Range[] = [];

let text = "";

let lastPos = 0;

let pos = 0;

const ranges = createMap<Range>();

while (pos < source.length) {

if (source.charCodeAt(pos) === CharacterCodes.openBracket &&

(source.charCodeAt(pos + 1) === CharacterCodes.hash || source.charCodeAt(pos + 1) === CharacterCodes.$)) {

const saved = pos;

pos += 2;

const s = pos;

consumeIdentifier();

const e = pos;

if (source.charCodeAt(pos) === CharacterCodes.bar) {

pos++;

text += source.substring(lastPos, saved);

const name = s === e

? source.charCodeAt(saved + 1) === CharacterCodes.hash ? "selection" : "extracted"

: source.substring(s, e);

activeRanges.push({ name, start: text.length, end: undefined });

lastPos = pos;

continue;

}

else {

pos = saved;

}

}

else if (source.charCodeAt(pos) === CharacterCodes.bar && source.charCodeAt(pos + 1) === CharacterCodes.closeBracket) {

text += source.substring(lastPos, pos);

activeRanges[activeRanges.length - 1].end = text.length;

const range = activeRanges.pop();

if (range.name in ranges) {

throw new Error(`Duplicate name of range ${range.name}`);

}

ranges.set(range.name, range);

pos += 2;

lastPos = pos;

continue;

}

pos++;

}

text += source.substring(lastPos, pos);

function consumeIdentifier() {

while (isIdentifierPart(source.charCodeAt(pos), ScriptTarget.Latest)) {

pos++;

}

}

return { source: text, ranges };

const options = {

indentSize: 4,

tabSize: 4,

newLineCharacter,

convertTabsToSpaces: true,

indentStyle: ts.IndentStyle.Smart,

insertSpaceAfterConstructor: false,

insertSpaceAfterCommaDelimiter: true,

insertSpaceAfterSemicolonInForStatements: true,

insertSpaceBeforeAndAfterBinaryOperators: true,

insertSpaceAfterKeywordsInControlFlowStatements: true,

insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,

insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,

insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,

insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,

insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,

insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,

insertSpaceBeforeFunctionParenthesis: false,

placeOpenBraceOnNewLineForFunctions: false,

placeOpenBraceOnNewLineForControlBlocks: false,

};

if (action) {

action(options);

}

const rulesProvider = new formatting.RulesProvider();

rulesProvider.ensureUpToDate(options);

return rulesProvider;

return it(caption, () => {

const t = extractTest(s);

const file = createSourceFile("a.ts", t.source, ScriptTarget.Latest, /*setParentNodes*/ true);

const selectionRange = t.ranges.get("selection");

if (!selectionRange) {

throw new Error(`Test ${s} does not specify selection range`);

}

const result = refactor.extractMethod.getRangeToExtract(file, createTextSpanFromBounds(selectionRange.start, selectionRange.end));

assert(result.targetRange === undefined, "failure expected");

const sortedErrors = result.errors.map(e => <string>e.messageText).sort();

assert.deepEqual(sortedErrors, expectedErrors.sort(), "unexpected errors");

});

const t = extractTest(s);

const f = createSourceFile("a.ts", t.source, ScriptTarget.Latest, /*setParentNodes*/ true);

const selectionRange = t.ranges.get("selection");

if (!selectionRange) {

throw new Error(`Test ${s} does not specify selection range`);

}

const result = refactor.extractMethod.getRangeToExtract(f, createTextSpanFromBounds(selectionRange.start, selectionRange.end));

const expectedRange = t.ranges.get("extracted");

if (expectedRange) {

let start: number, end: number;

if (ts.isArray(result.targetRange.range)) {

start = result.targetRange.range[0].getStart(f);

end = ts.lastOrUndefined(result.targetRange.range).getEnd();

}

else {

start = result.targetRange.range.getStart(f);

end = result.targetRange.range.getEnd();

}

assert.equal(start, expectedRange.start, "incorrect start of range");

assert.equal(end, expectedRange.end, "incorrect end of range");

}

else {

assert.isTrue(!result.targetRange, `expected range to extract to be undefined`);

}

it(caption, () => {

Harness.Baseline.runBaseline(`extractMethod/${caption}.ts`, () => {

const t = extractTest(text);

const selectionRange = t.ranges.get("selection");

if (!selectionRange) {

throw new Error(`Test ${caption} does not specify selection range`);

}

const f = {

path: "/a.ts",

content: t.source

};

const host = projectSystem.createServerHost([f, projectSystem.libFile]);

const projectService = projectSystem.createProjectService(host);

projectService.openClientFile(f.path);

const program = projectService.inferredProjects[0].getLanguageService().getProgram();

const sourceFile = program.getSourceFile(f.path);

const context: RefactorContext = {

cancellationToken: { throwIfCancellationRequested() { }, isCancellationRequested() { return false; } },

newLineCharacter,

program,

file: sourceFile,

startPosition: -1,

rulesProvider: getRuleProvider()

};

const result = refactor.extractMethod.getRangeToExtract(sourceFile, createTextSpanFromBounds(selectionRange.start, selectionRange.end));

assert.equal(result.errors, undefined, "expect no errors");

const results = refactor.extractMethod.getPossibleExtractions(result.targetRange, context);

const data: string[] = [];

data.push(`// ==ORIGINAL==`);

data.push(sourceFile.text);

for (const r of results) {

const { renameLocation, edits } = refactor.extractMethod.getExtractionAtIndex(result.targetRange, context, results.indexOf(r));

assert.lengthOf(edits, 1);

data.push(`// ==SCOPE::${r.scopeDescription}==`);

const newText = textChanges.applyChanges(sourceFile.text, edits[0].textChanges);

const newTextWithRename = newText.slice(0, renameLocation) + "/*RENAME*/" + newText.slice(renameLocation);

data.push(newTextWithRename);

}

return data.join(newLineCharacter);

});

});