TypeScript Position.translate方法代码示例

 async provideCompletionItems(document: TextDocument, position: Position):
         Promise<CompletionItem[]> {
     // TODO(gabriel): use LeanInputAbbreviator.active() instead
     if (!isInputCompletion(document, position)) {
         const message = await this.server.complete(document.fileName, position.line + 1, position.character);
         const completions: CompletionItem[] = [];
         if (message.completions) {
             for (const completion of message.completions) {
                 const item = new CompletionItem(completion.text, CompletionItemKind.Function);
                 item.range = new Range(position.translate(0, -message.prefix.length), position);
                 if (completion.tactic_params) {
                     item.detail = completion.tactic_params.join(' ');
                 } else {
                     item.detail = completion.type;
                 }
                 item.documentation = new MarkdownString(completion.doc);
                 completions.push(item);
             }
         }
         for (const kw of keywords) {
             completions.push(new CompletionItem(kw, CompletionItemKind.Keyword));
         }
         return completions;
     } else {
         return null;
     }
 }

	private previousTokenPosition(document: TextDocument, position: Position): Position {
		while (position.character > 0) {
			let word = document.getWordRangeAtPosition(position);
			if (word) {
				return word.start;
			}
			position = position.translate(0, -1);
		}
		return null;
	}

	/**
	 * Prepare the area around the position for insertion of the jsdoc.
	 *
	 * Removes any the prefix and suffix of a possible jsdoc
	 */
	private prepForDocCompletion(editor: TextEditor, position: Position): Thenable<Position> {
		const line = editor.document.lineAt(position.line).text;
		const prefix = line.slice(0, position.character).match(/\/\**\s*$/);
		const suffix = line.slice(position.character).match(/^\s*\**\//);
		if (!prefix && !suffix) {
			// Nothing to remove
			return Promise.resolve(position);
		}

		const start = position.translate(0, prefix ? -prefix[0].length : 0);
		return editor.edit(
			edits => {
				edits.delete(new Range(start, position.translate(0, suffix ? suffix[0].length : 0)));
			}, {
				undoStopBefore: true,
				undoStopAfter: false
			}).then(() => start);
	}

	/**
	 * Returns the next character in the stream and advances it.
	 * Also returns NaN when no more characters are available.
	 * @returns {Number}
	 */
	next() {
		if (this.eof()) {
			return NaN;
		}

		const line = this.document.lineAt(this.pos.line).text;
		let code: number;
		if (this.pos.character < line.length) {
			code = line.charCodeAt(this.pos.character);
			this.pos = this.pos.translate(0, 1);
		} else {
			code = this._eol.charCodeAt(this.pos.character - line.length);
			this.pos = new Position(this.pos.line + 1, 0);
		}

		if (this.eof()) {
			// restrict pos to eof, if in case it got moved beyond eof
			this.pos = new Position(this._eof.line, this._eof.character);
		}

		return code;
	}

    public syncWindows() {
        let editor = window.activeTextEditor;
        if (!editor) {
            return;
        }

        let doc = editor.document;

        let editors: TextEditor[] = window.visibleTextEditors;
        var i = 0;
        var previousEditorPos = 0;
        let previousPos: Position;
    
        for (var theEditor of editors) {
            console.log(theEditor.document.positionAt);

            if (theEditor.viewColumn != ViewColumn.One) {
                theEditor.revealRange(new Range(previousPos, previousPos.translate(theEditor.document.lineCount)));
            } else {
                previousPos = theEditor.selection.active;
            }
        }
    }

			edits => {
				edits.delete(new Range(start, position.translate(0, suffix ? suffix[0].length : 0)));
			}, {