| // Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file | |
| // for details. All rights reserved. Use of this source code is governed by a | |
| // BSD-style license that can be found in the LICENSE file. | |
| import 'package:analyzer_plugin/protocol/protocol_common.dart'; | |
| /// An object that can map the offsets before a sequence of edits to the offsets | |
| /// after applying the edits. | |
| abstract class OffsetMapper { | |
| /// A mapper used for files that were not modified. | |
| static OffsetMapper identity = _IdentityMapper(); | |
| /// Return a mapper representing the file modified by the given [edits]. | |
| factory OffsetMapper.forEdits(List<SourceEdit> edits) => _EditMapper(edits); | |
| /// Return a mapper representing the file modified by an insertion at [offset] | |
| /// the given with [length]. | |
| factory OffsetMapper.forInsertion(int offset, int length) => | |
| _SimpleSourceEditMapper(offset, 0, length); | |
| /// Return a mapper representing the file modified by an insertion at [offset] | |
| /// with [replacemnet] text overwriting the given [length]. | |
| factory OffsetMapper.forReplacement( | |
| int offset, int length, String replacement) => | |
| _SimpleSourceEditMapper(offset, length, replacement.length); | |
| /// Return a mapper representing [rebased] rebased by [rebaser]. | |
| /// | |
| /// Warning: this does not currently handle cases where the [rebased] mapper | |
| /// contains an insert or deletion in the middle of a range deleted by | |
| /// [rebaser]. This is not a case that currently needs to be supported. | |
| factory OffsetMapper.rebase(OffsetMapper rebaser, OffsetMapper rebased) { | |
| return _RebasedOffsetMapper(rebaser, rebased); | |
| } | |
| /// Return a mapper representing a sequence of edits made in order, with the | |
| /// offsets coming out of [first] being the offsets passed into [second]. | |
| factory OffsetMapper.sequence(OffsetMapper first, OffsetMapper second) { | |
| return _OffsetMapperChain([first, second]); | |
| } | |
| /// Return the post-edit offset that corresponds to the given pre-edit | |
| /// [offset], or `null` when that offset has been deleted. | |
| int map(int offset); | |
| } | |
| /// A mapper used for files that were modified by a set of edits. | |
| class _EditMapper implements OffsetMapper { | |
| /// A list whose elements are the highest pre-edit offset for which the | |
| /// corresponding element of [_deltas] should be applied. | |
| final List<int> _offsets = []; | |
| /// A list whose elements are the deltas to be applied for all pre-edit | |
| /// offsets that are less than or equal to the corresponding element of | |
| /// [_offsets]. | |
| final List<int> _deltas = []; | |
| /// Initialize a newly created mapper based on the given set of [edits]. | |
| _EditMapper(List<SourceEdit> edits) { | |
| _initializeDeltas(edits); | |
| } | |
| @override | |
| int map(int offset) => offset + _deltaFor(offset); | |
| /// Return the delta to be added to the pre-edit [offset] to produce the | |
| /// post-edit offset. | |
| int _deltaFor(int offset) { | |
| for (var i = 0; i < _offsets.length; i++) { | |
| var currentOffset = _offsets[i]; | |
| if (currentOffset >= offset || currentOffset < 0) { | |
| return _deltas[i]; | |
| } | |
| } | |
| // We should never get here because [_initializeDeltas] always adds an | |
| // offset/delta pair at the end of the list whose offset is less than zero. | |
| return 0; | |
| } | |
| /// Initialize the list of old offsets and deltas used by [_deltaFor]. | |
| void _initializeDeltas(List<SourceEdit> edits) { | |
| var previousDelta = 0; | |
| for (var edit in edits) { | |
| var offset = edit.offset; | |
| var length = edit.length; | |
| _offsets.add(offset); | |
| _deltas.add(previousDelta); | |
| previousDelta += (edit.replacement.length - length); | |
| } | |
| _offsets.add(-1); | |
| _deltas.add(previousDelta); | |
| } | |
| } | |
| /// A mapper used for files that were not modified. | |
| class _IdentityMapper implements OffsetMapper { | |
| @override | |
| int map(int offset) => offset; | |
| } | |
| class _OffsetMapperChain implements OffsetMapper { | |
| final List<OffsetMapper> innerMappers; | |
| _OffsetMapperChain(this.innerMappers); | |
| @override | |
| int map(int offset) { | |
| for (final mapper in innerMappers) { | |
| offset = mapper.map(offset); | |
| if (offset == null) { | |
| break; | |
| } | |
| } | |
| return offset; | |
| } | |
| } | |
| class _RebasedOffsetMapper implements OffsetMapper { | |
| final OffsetMapper rebaser; | |
| final OffsetMapper rebased; | |
| _RebasedOffsetMapper(this.rebaser, this.rebased); | |
| @override | |
| int map(int offset) { | |
| final rebasedOffset = rebased.map(offset); | |
| final rebasingOffset = rebaser.map(offset); | |
| if (rebasedOffset == null || rebasingOffset == null) { | |
| return null; | |
| } | |
| final delta = rebasedOffset - offset; | |
| return rebasingOffset + delta; | |
| } | |
| } | |
| class _SimpleSourceEditMapper implements OffsetMapper { | |
| /// The offset where the replacement begins. | |
| final int offset; | |
| /// The length of text to be replaced. | |
| final int replacedLength; | |
| /// The length of text to be inserted as a replacement. | |
| final int replacementLength; | |
| _SimpleSourceEditMapper( | |
| this.offset, this.replacedLength, this.replacementLength); | |
| @override | |
| int map(int offset) { | |
| if (offset < this.offset) { | |
| return offset; | |
| } | |
| if (offset < this.offset + replacedLength) { | |
| return null; | |
| } | |
| return offset + replacementLength - replacedLength; | |
| } | |
| } |