Examples with ReplaceRegion org.eclipse.xtext.util.ReplaceRegion used on opensource projects

Example 26 with ReplaceRegion

use of org.eclipse.xtext.util.ReplaceRegion in project xtext-eclipse by eclipse.

the class XbaseReferenceUpdater method processReferringResource.

@Override
protected void processReferringResource(Resource referringResource, Iterable<IReferenceDescription> referenceDescriptions, ElementRenameArguments elementRenameArguments, IRefactoringUpdateAcceptor updateAcceptor, IProgressMonitor monitor) {
    ImportAwareUpdateAcceptor importAwareUpdateAcceptor = createUpdateAcceptor(referringResource, updateAcceptor);
    Iterable<IReferenceDescription> importTypeReferences = getImportTypeReferences(referenceDescriptions);
    super.processReferringResource(referringResource, importTypeReferences, elementRenameArguments, importAwareUpdateAcceptor, monitor);
    importAwareUpdateAcceptor.getImportSection().update();
    Iterable<IReferenceDescription> notImportTypeReferences = getNotImportTypeReferences(referenceDescriptions);
    super.processReferringResource(referringResource, notImportTypeReferences, elementRenameArguments, importAwareUpdateAcceptor, monitor);
    List<ReplaceRegion> importChanges = importAwareUpdateAcceptor.getImportSection().rewrite();
    TextEdit importChangeEdit = replaceConverter.convertToTextEdit(importChanges);
    if (importChangeEdit != null)
        updateAcceptor.accept(referringResource.getURI(), importChangeEdit);
}

Example 27 with ReplaceRegion

use of org.eclipse.xtext.util.ReplaceRegion in project xtext-eclipse by eclipse.

the class XbaseTemplateContext method evaluate.

@Override
public TemplateBuffer evaluate(Template template) throws BadLocationException, TemplateException {
    XtextDocument xDocument = (XtextDocument) getDocument();
    // Ensure clean state before evaluation starts
    imports.clear();
    TemplateBuffer resolvedContent = super.evaluate(template);
    Position position = new Position(getCompletionOffset(), 0);
    List<ReplaceRegion> rewrite = createImports(imports, xDocument);
    if (rewrite.size() > 0 && !isReadOnly()) {
        // Remember the completion offset before performing doc changes
        // $NON-NLS-1$
        final String category = "__template_position_import_section" + System.currentTimeMillis();
        IPositionUpdater updater = new DefaultPositionUpdater(category);
        xDocument.addPositionCategory(category);
        xDocument.addPositionUpdater(updater);
        xDocument.addPosition(position);
        try {
            replaceConverter.convertToTextEdit(rewrite).apply(xDocument);
            // restore CompletionOffset
            setCompletionOffset(position.getOffset());
        } catch (BadLocationException e) {
            throw new TemplateException(e);
        } finally {
            xDocument.removePosition(position);
            xDocument.removePositionUpdater(updater);
            try {
                xDocument.removePositionCategory(category);
            } catch (BadPositionCategoryException e) {
                throw new TemplateException(e);
            }
        }
    }
    return resolvedContent;
}

Example 28 with ReplaceRegion

use of org.eclipse.xtext.util.ReplaceRegion in project dsl-devkit by dsldevkit.

the class FixedPartialParsingHelper method reparse.

@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public IParseResult reparse(final IParser parser, final IParseResult previousParseResult, final ReplaceRegion changedRegion) {
    if (parser == null) {
        throw new NullPointerException("parser may not be null");
    }
    if (previousParseResult == null) {
        throw new NullPointerException("previousParseResult and previousParseResult.rootNode may not be null");
    }
    ICompositeNode oldRootNode = previousParseResult.getRootNode();
    if (changedRegion.getEndOffset() > oldRootNode.getTotalLength()) {
        log.error("Invalid " + changedRegion + " originalLength=" + oldRootNode.getTotalLength());
        return fullyReparse(parser, previousParseResult, changedRegion);
    }
    if (changedRegion.getOffset() >= oldRootNode.getTotalLength() && changedRegion.getText().trim().length() == 0) {
        return fullyReparse(parser, previousParseResult, changedRegion);
    }
    ReplaceRegion replaceRegion = tokenRegionProvider.getTokenReplaceRegion(insertChangeIntoReplaceRegion(oldRootNode, changedRegion), changedRegion);
    if (isNullEdit(oldRootNode, replaceRegion)) {
        return previousParseResult;
    }
    PartialParsingPointers parsingPointers = calculatePartialParsingPointers(previousParseResult, replaceRegion.getOffset(), replaceRegion.getLength());
    List<ICompositeNode> validReplaceRootNodes = parsingPointers.getValidReplaceRootNodes();
    ICompositeNode oldCompositeNode = null;
    String reparseRegion = "";
    for (int i = validReplaceRootNodes.size() - 1; i >= 0; --i) {
        oldCompositeNode = validReplaceRootNodes.get(i);
        if (!(oldCompositeNode instanceof SyntheticCompositeNode) && !isRangePartOfExceedingLookAhead((CompositeNode) oldCompositeNode, replaceRegion)) {
            boolean replaceAtEnd = oldCompositeNode.getTotalEndOffset() == replaceRegion.getEndOffset();
            reparseRegion = insertChangeIntoReplaceRegion(oldCompositeNode, replaceRegion);
            if (!"".equals(reparseRegion)) {
                if (!replaceAtEnd || !Character.isWhitespace(reparseRegion.charAt(reparseRegion.length() - 1))) {
                    if (log.isDebugEnabled()) {
                        log.debug("replace region: [" + oldCompositeNode.getTotalOffset() + " / length: " + oldCompositeNode.getTotalLength() + " of [" + oldRootNode.getTotalOffset() + " / lenght: " + oldRootNode.getTotalLength() + "]");
                    }
                    break;
                }
            }
        }
    }
    if (oldCompositeNode == null || reparseRegion.equals("") || oldCompositeNode == oldRootNode) {
        return fullyReparse(parser, previousParseResult, replaceRegion);
    }
    EObject entryRuleOrRuleCall = parsingPointers.findEntryRuleOrRuleCall(oldCompositeNode);
    IParseResult newParseResult = null;
    try {
        if (entryRuleOrRuleCall instanceof RuleCall) {
            newParseResult = parser.parse((RuleCall) entryRuleOrRuleCall, new StringReader(reparseRegion), oldCompositeNode.getLookAhead());
        } else {
            newParseResult = parser.parse((ParserRule) entryRuleOrRuleCall, new StringReader(reparseRegion));
        }
    } catch (ParseException exc) {
    }
    if (newParseResult == null || newParseResult.hasSyntaxErrors()) {
        // on error fully reparse
        return fullyReparse(parser, previousParseResult, replaceRegion);
    }
    if (oldRootNode.equals(oldCompositeNode)) {
        unloadSemanticObject(previousParseResult.getRootASTElement());
        return newParseResult;
    }
    EObject oldSemanticParentElement = oldCompositeNode.getParent().getSemanticElement();
    EObject oldSemanticElement = null;
    if (oldCompositeNode.hasDirectSemanticElement()) {
        oldSemanticElement = oldCompositeNode.getSemanticElement();
    } else {
        List<ICompositeNode> nodesEnclosingRegion = parsingPointers.getNodesEnclosingRegion();
        for (int i = nodesEnclosingRegion.size() - 1; i >= 0; --i) {
            ICompositeNode enclosingNode = nodesEnclosingRegion.get(i);
            if (enclosingNode == oldCompositeNode) {
                break;
            }
            if (enclosingNode.hasDirectSemanticElement()) {
                oldSemanticElement = enclosingNode.getSemanticElement();
            }
        }
        if (oldSemanticElement == null) {
            return fullyReparse(parser, previousParseResult, replaceRegion);
        }
    }
    if (oldSemanticElement == oldSemanticParentElement) {
        throw new IllegalStateException("oldParent == oldElement");
    }
    if (oldSemanticParentElement != null) {
        EStructuralFeature feature = oldSemanticElement.eContainingFeature();
        if (feature == null) {
            return fullyReparse(parser, previousParseResult, replaceRegion);
        }
        oldSemanticParentElement = oldSemanticElement.eContainer();
        if (feature.isMany()) {
            List featureValueList = (List) oldSemanticParentElement.eGet(feature);
            int index = featureValueList.indexOf(oldSemanticElement);
            unloadSemanticObject(oldSemanticElement);
            featureValueList.set(index, newParseResult.getRootASTElement());
        } else {
            unloadSemanticObject(oldSemanticElement);
            oldSemanticParentElement.eSet(feature, newParseResult.getRootASTElement());
        }
        ((ParseResult) newParseResult).setRootASTElement(previousParseResult.getRootASTElement());
    } else {
        unloadSemanticObject(oldSemanticElement);
    }
    if (oldCompositeNode != oldRootNode) {
        nodeModelBuilder.replaceAndTransferLookAhead(oldCompositeNode, newParseResult.getRootNode());
        ((ParseResult) newParseResult).setRootNode(oldRootNode);
        StringBuilder builder = new StringBuilder(oldRootNode.getText());
        replaceRegion.applyTo(builder);
        nodeModelBuilder.setCompleteContent(oldRootNode, builder.toString());
    }
    return newParseResult;
}

Example 29 with ReplaceRegion

use of org.eclipse.xtext.util.ReplaceRegion in project n4js by eclipse.

the class AbstractSmokeTester method skipNodesInBetween.

private void skipNodesInBetween(CharSequence input) throws Exception {
    String string = input.toString();
    Script script = completeScript(string);
    if (script != null) {
        XtextResource resource = (XtextResource) script.eResource();
        ICompositeNode rootNode = resource.getParseResult().getRootNode();
        ReplaceRegion region = null;
        for (INode node : rootNode.getAsTreeIterable()) {
            if (node instanceof ICompositeNode && !(node instanceof SyntheticCompositeNode)) {
                ICompositeNode casted = (ICompositeNode) node;
                int offset = node.getTotalOffset();
                int length = node.getTotalLength();
                if (length != 0) {
                    if (casted.getFirstChild().equals(casted.getLastChild())) {
                        if (region == null || region.getOffset() != offset || region.getLength() != length) {
                            region = new ReplaceRegion(offset, length, "");
                            StringBuilder builder = new StringBuilder(rootNode.getText());
                            region.applyTo(builder);
                            processFile(builder.toString());
                        }
                    }
                }
            }
        }
    }
}

Example 30 with ReplaceRegion

use of org.eclipse.xtext.util.ReplaceRegion in project xtext-xtend by eclipse.

the class JavaDocTypeReferenceProviderTest method testComputation_9.

@Test
public void testComputation_9() {
    try {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("package foo");
        _builder.newLine();
        _builder.newLine();
        _builder.append("/**");
        _builder.newLine();
        _builder.append("* {@link    String #length()  }");
        _builder.newLine();
        _builder.append("*/");
        _builder.newLine();
        _builder.append("class Foo{}");
        _builder.newLine();
        final String input = _builder.toString();
        Resource _eResource = this.clazz(input).eResource();
        final XtextResource resource = ((XtextResource) _eResource);
        final ICompositeNode rootNode = resource.getParseResult().getRootNode();
        final List<ReplaceRegion> regions = this.javaDocTypeReferenceProvider.computeTypeRefRegions(rootNode);
        Assert.assertEquals(1, regions.size());
        Assert.assertEquals("String", IterableExtensions.<ReplaceRegion>head(regions).getText());
    } catch (Throwable _e) {
        throw Exceptions.sneakyThrow(_e);
    }
}