| /*=============================================================================# |
| # Copyright (c) 2008, 2019 Stephan Wahlbrink and others. |
| # |
| # This program and the accompanying materials are made available under the |
| # terms of the Eclipse Public License 2.0 which is available at |
| # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 |
| # which is available at https://www.apache.org/licenses/LICENSE-2.0. |
| # |
| # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 |
| # |
| # Contributors: |
| # Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation |
| #=============================================================================*/ |
| |
| package org.eclipse.statet.r.ui.sourceediting; |
| |
| import static org.eclipse.statet.jcommons.lang.ObjectUtils.nonNullAssert; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.function.BiFunction; |
| |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.jface.text.BadLocationException; |
| import org.eclipse.jface.text.BadPartitioningException; |
| import org.eclipse.jface.text.IDocument; |
| |
| import org.eclipse.statet.jcommons.collections.CollectionUtils; |
| import org.eclipse.statet.jcommons.collections.ImCollections; |
| import org.eclipse.statet.jcommons.lang.Nullable; |
| |
| import org.eclipse.statet.ecommons.text.core.IFragmentDocument; |
| import org.eclipse.statet.ecommons.text.core.IPartitionConstraint; |
| |
| import org.eclipse.statet.internal.r.ui.FCallNamePattern; |
| import org.eclipse.statet.internal.r.ui.editors.RElementCompletionProposal; |
| import org.eclipse.statet.internal.r.ui.editors.RKeywordCompletionProposal; |
| import org.eclipse.statet.internal.r.ui.editors.RSimpleCompletionProposal; |
| import org.eclipse.statet.ltk.ast.core.AstNode; |
| import org.eclipse.statet.ltk.model.core.elements.IModelElement; |
| import org.eclipse.statet.ltk.ui.IElementLabelProvider; |
| import org.eclipse.statet.ltk.ui.sourceediting.ISourceEditor; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.AssistInvocationContext; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.AssistProposalCollector; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.ContentAssist; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.IAssistCompletionProposal; |
| import org.eclipse.statet.ltk.ui.sourceediting.assist.IContentAssistComputer; |
| import org.eclipse.statet.r.core.IRCoreAccess; |
| import org.eclipse.statet.r.core.RCore; |
| import org.eclipse.statet.r.core.RSymbolComparator; |
| import org.eclipse.statet.r.core.RSymbolComparator.PrefixPattern; |
| import org.eclipse.statet.r.core.data.CombinedRElement; |
| import org.eclipse.statet.r.core.model.ArgsDefinition; |
| import org.eclipse.statet.r.core.model.IRElement; |
| import org.eclipse.statet.r.core.model.IRFrame; |
| import org.eclipse.statet.r.core.model.IRFrameInSource; |
| import org.eclipse.statet.r.core.model.IRLangElement; |
| import org.eclipse.statet.r.core.model.IRMethod; |
| import org.eclipse.statet.r.core.model.RCoreFunctions; |
| import org.eclipse.statet.r.core.model.RElementAccess; |
| import org.eclipse.statet.r.core.model.RElementName; |
| import org.eclipse.statet.r.core.model.RModel; |
| import org.eclipse.statet.r.core.pkgmanager.IRPkgManager; |
| import org.eclipse.statet.r.core.rlang.RTokens; |
| import org.eclipse.statet.r.core.rsource.ast.FCall; |
| import org.eclipse.statet.r.core.rsource.ast.RAst; |
| import org.eclipse.statet.r.core.rsource.ast.RAst.FCallArgMatch; |
| import org.eclipse.statet.r.core.rsource.ast.RAstNode; |
| import org.eclipse.statet.r.core.source.IRDocumentConstants; |
| import org.eclipse.statet.r.core.source.RHeuristicTokenScanner; |
| import org.eclipse.statet.r.ui.RLabelProvider; |
| import org.eclipse.statet.r.ui.editors.IRSourceEditor; |
| import org.eclipse.statet.r.ui.sourceediting.RAssistInvocationContext.FCallInfo; |
| import org.eclipse.statet.r.ui.sourceediting.RFrameSearchPath.RFrameIterator; |
| import org.eclipse.statet.rhelp.core.REnvHelp; |
| import org.eclipse.statet.rhelp.core.RHelpManager; |
| import org.eclipse.statet.rhelp.core.RHelpTopicEntry; |
| import org.eclipse.statet.rhelp.core.RPkgHelp; |
| import org.eclipse.statet.rj.data.RObject; |
| import org.eclipse.statet.rj.data.RReference; |
| import org.eclipse.statet.rj.renv.core.REnv; |
| import org.eclipse.statet.rj.renv.core.RPkgBuilt; |
| import org.eclipse.statet.rj.renv.core.RPkgCompilation; |
| import org.eclipse.statet.rj.renv.core.RPkgUtils; |
| import org.eclipse.statet.rj.renv.runtime.RPkgManagerDataset; |
| |
| |
| public class RElementCompletionComputer implements IContentAssistComputer { |
| |
| |
| private static final IPartitionConstraint NO_R_COMMENT_CONSTRAINT= new IPartitionConstraint() { |
| @Override |
| public boolean matches(final String partitionType) { |
| return (partitionType != IRDocumentConstants.R_COMMENT_CONTENT_TYPE); |
| }; |
| }; |
| |
| |
| private static final List<String> fgKeywords; |
| static { |
| final ArrayList<String> list= new ArrayList<>(); |
| Collections.addAll(list, RTokens.CONSTANT_WORDS); |
| Collections.addAll(list, RTokens.FLOWCONTROL_WORDS); |
| Collections.sort(list, RSymbolComparator.R_NAMES_COLLATOR); |
| list.trimToSize(); |
| fgKeywords= Collections.unmodifiableList(list); |
| } |
| |
| private static String toString(final Object value) { |
| if (value instanceof List) { |
| final List<String> list= (List<String>) value; |
| Collections.sort(list, RPkgUtils.NAMES_COLLATOR); |
| return CollectionUtils.toString(list, ", "); //$NON-NLS-1$ |
| } |
| return value.toString(); |
| } |
| |
| |
| public static class CompleteRuntime extends RElementCompletionComputer { |
| |
| public CompleteRuntime() { |
| super(RFrameSearchPath.ENGINE_MODE); |
| } |
| |
| } |
| |
| |
| protected static final int NA_PRIO= Integer.MIN_VALUE; |
| |
| protected static final int ARG_NAME_PRIO= 80; |
| |
| protected static final int ARG_TYPE_PRIO= 40; |
| protected static final int ARG_TYPE_NO_PRIO= -40; |
| |
| |
| private final IElementLabelProvider labelProvider= new RLabelProvider(RLabelProvider.NAMESPACE); |
| |
| private final int mode; |
| |
| private IRSourceEditor editor; |
| private ContentAssist assist; |
| |
| private final RFrameSearchPath searchPath= new RFrameSearchPath(); |
| |
| private boolean inDefault; |
| private boolean inString; |
| |
| private int pkgNamePrio; |
| private int helpTopicPrio; |
| |
| private IStatus resultStatus; |
| |
| |
| public RElementCompletionComputer() { |
| this(0); |
| } |
| |
| protected RElementCompletionComputer(final int mode) { |
| this.mode= mode; |
| } |
| |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public void sessionStarted(final ISourceEditor editor, final ContentAssist assist) { |
| this.editor= (editor instanceof IRSourceEditor) ? (IRSourceEditor) editor : null; |
| |
| this.assist= assist; |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| @Override |
| public void sessionEnded() { |
| this.searchPath.clear(); |
| |
| this.assist= null; |
| this.resultStatus= null; |
| } |
| |
| protected final void setStatus(final IStatus status) { |
| this.resultStatus= status; |
| } |
| |
| |
| protected final int getSearchMode(final RAssistInvocationContext context) { |
| if (this.mode != 0) { |
| return this.mode; |
| } |
| return context.getDefaultRFrameSearchMode(); |
| } |
| |
| |
| protected final boolean isSymbolCandidate(final String name) { |
| for (int i= 0; i < name.length(); i++) { |
| if (RTokens.isRobustSeparator(name.charAt(i))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private boolean isCompletable(RElementName elementName) { |
| if (elementName == null) { |
| return false; |
| } |
| do { |
| switch (elementName.getType()) { |
| case RElementName.SUB_INDEXED_S: |
| case RElementName.SUB_INDEXED_D: |
| return false; |
| } |
| if (elementName.getSegmentName() == null) { |
| return false; |
| } |
| elementName= elementName.getNextSegment(); |
| } |
| while (elementName != null); |
| return true; |
| } |
| |
| private RAstNode getRAstNode(final RAssistInvocationContext context) { |
| AstNode node= context.getInvocationAstSelection().getCovering(); |
| if (node == null) { |
| node= context.getAstInfo().getRoot(); |
| } |
| return (node instanceof RAstNode) ? (RAstNode) node : null; |
| } |
| |
| |
| @Override |
| public IStatus computeCompletionProposals(final AssistInvocationContext context, |
| final int mode, final AssistProposalCollector proposals, |
| final IProgressMonitor monitor) { |
| this.resultStatus= null; |
| |
| if (context instanceof RAssistInvocationContext) { |
| computeCompletionProposals((RAssistInvocationContext) context, mode, proposals, |
| monitor ); |
| } |
| |
| return this.resultStatus; |
| } |
| |
| @Override |
| public IStatus computeInformationProposals(final AssistInvocationContext context, |
| final AssistProposalCollector proposals, final IProgressMonitor monitor) { |
| this.resultStatus= null; |
| |
| if (context instanceof RAssistInvocationContext) { |
| doComputeContextProposals((RAssistInvocationContext) context, proposals, monitor); |
| } |
| |
| return this.resultStatus; |
| } |
| |
| protected void computeCompletionProposals(final RAssistInvocationContext context, final int mode, |
| final AssistProposalCollector proposals, final IProgressMonitor monitor) { |
| if (context.getModelInfo() == null) { |
| return; |
| } |
| |
| // Get node |
| final RAstNode node= getRAstNode(context); |
| |
| // Get prefix |
| final RElementName prefixName= context.getIdentifierElementName(); |
| if (prefixName == null) { |
| return; |
| } |
| |
| this.inString= (context.getInvocationContentType() == IRDocumentConstants.R_STRING_CONTENT_TYPE); |
| this.inDefault= !this.inString; |
| |
| this.pkgNamePrio= NA_PRIO; |
| this.helpTopicPrio= NA_PRIO; |
| |
| if (prefixName.getNextSegment() == null) { |
| final String help= checkHelp(context); |
| if (help != null) { |
| doComputeHelpTopicProposals(context, help, node, ARG_TYPE_PRIO, proposals); |
| |
| if (prefixName.getScope() == null) { |
| doComputePkgNameProposals(context, ARG_TYPE_NO_PRIO, proposals); |
| } |
| return; |
| } |
| |
| doComputeArgumentProposals(context, proposals, monitor); |
| if (this.inDefault) { |
| doComputeMainProposals(context, node, proposals, monitor); |
| } |
| |
| if (this.mode == 0 && this.inDefault) { |
| doComputeKeywordProposals(context, proposals, monitor); |
| } |
| |
| if (this.mode == 0) { |
| if (isPackageName(prefixName)) { |
| if (this.pkgNamePrio > 0) { |
| doComputePkgNameProposals(context, this.pkgNamePrio, proposals); |
| } |
| else if (!prefixName.getSegmentName().isEmpty()) { |
| doComputePkgNameProposals(context, ARG_TYPE_NO_PRIO, proposals); |
| } |
| } |
| { if (this.helpTopicPrio > 0) { |
| doComputeHelpTopicProposals(context, null, node, this.helpTopicPrio, proposals); |
| } |
| } |
| } |
| } |
| else { |
| doComputeSubProposals(context, node, proposals, monitor); |
| } |
| } |
| |
| |
| private String checkHelp(final RAssistInvocationContext context) { |
| try { |
| if (context.getIdentifierOffset() > 0 |
| && context.getDocument().getChar(context.getIdentifierOffset() - 1) == '?') { |
| final String prefix= context.computeIdentifierPrefix(context.getIdentifierOffset() - 1); |
| if (prefix != null && !prefix.isEmpty()) { |
| if (prefix.equals("class") || prefix.equals("methods")) { //$NON-NLS-1$ //$NON-NLS-2$ |
| return prefix; |
| } |
| return null; |
| } |
| return ""; //$NON-NLS-1$ |
| } |
| return null; |
| } |
| catch (final BadPartitioningException | BadLocationException e) { |
| return null; |
| } |
| } |
| |
| protected List<? extends IRLangElement> getChildren(final RAssistInvocationContext context, |
| IRLangElement e) { |
| if (e instanceof RReference) { |
| final RReference ref= (RReference) e; |
| final RObject rObject= ref.getResolvedRObject(); |
| if (rObject == null && e instanceof CombinedRElement && context.getTool() != null) { |
| context.getToolReferencesUtil().resolve(ref, 0); |
| } |
| if (rObject instanceof CombinedRElement) { |
| e= (CombinedRElement) rObject; |
| } |
| } |
| return e.getModelChildren(null); |
| } |
| |
| protected boolean doComputeArgumentProposals(final RAssistInvocationContext context, |
| final AssistProposalCollector proposals, |
| final IProgressMonitor monitor) { |
| final FCallInfo fCallInfo= context.getFCallInfo(); |
| if (fCallInfo != null) { |
| boolean argName= false; |
| boolean argValue= false; |
| final int argIdx= fCallInfo.getArgIdx(context.getInvocationOffset()); |
| if (argIdx >= 0) { |
| final FCall.Arg arg= fCallInfo.getArg(argIdx); |
| final int argBeginOffset= fCallInfo.getArgBeginOffset(argIdx); |
| |
| IDocument document= context.getDocument(); |
| int offsetShift= 0; |
| if (document instanceof IFragmentDocument) { |
| final IFragmentDocument inputDoc= (IFragmentDocument) document; |
| document= inputDoc.getMasterDocument(); |
| offsetShift= inputDoc.getOffsetInMasterDocument(); |
| } |
| |
| if (argBeginOffset != Integer.MIN_VALUE) { |
| final RHeuristicTokenScanner scanner= context.getRHeuristicTokenScanner(); |
| scanner.configure(document, NO_R_COMMENT_CONSTRAINT); |
| final int offset= context.getIdentifierOffset(); |
| if (argBeginOffset == offset |
| || scanner.findNonBlankForward( |
| argBeginOffset + offsetShift, offset + offsetShift, true) < 0 ) { |
| argName= (this.inDefault |
| && (context.getIdentifierElementName().getScope() == null) ); |
| argValue= true; |
| } |
| } |
| |
| if (!argValue && arg != null && arg.getAssignOffset() != AstNode.NA_OFFSET) { |
| final RHeuristicTokenScanner scanner= context.getRHeuristicTokenScanner(); |
| scanner.configure(document, NO_R_COMMENT_CONSTRAINT); |
| final int offset= context.getIdentifierOffset(); |
| if (argBeginOffset == offset |
| || scanner.findNonBlankForward( |
| arg.getAssignOffset() + offsetShift + 1, offset + offsetShift, true) < 0 ) { |
| argValue= true; |
| } |
| } |
| } |
| if (argName || argValue) { |
| doComputeFCallArgumentProposals(context, fCallInfo, argIdx, argName, argValue, |
| proposals); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| protected void doComputeMainProposals(final RAssistInvocationContext context, |
| final RAstNode node, |
| final AssistProposalCollector proposals, |
| final IProgressMonitor monitor) { |
| final RElementName prefixName= context.getIdentifierElementName(); |
| final String prefixSegmentName= nonNullAssert(prefixName.getSegmentName()); |
| |
| this.searchPath.init(context, node, getSearchMode(context), prefixName.getScope()); |
| |
| final RSymbolComparator.PrefixPattern pattern= new RSymbolComparator.PrefixPattern(prefixSegmentName); |
| final int offset= context.getIdentifierLastSegmentOffset(); |
| final Set<String> mainNames= new HashSet<>(); |
| final List<String> methodNames= new ArrayList<>(); |
| |
| for (final RFrameIterator iter= this.searchPath.iterator(); iter.hasNext();) { |
| final IRFrame envir= iter.next(); |
| |
| final List<? extends IRElement> elements= envir.getModelChildren(null); |
| for (final IRElement element : elements) { |
| final RElementName elementName= element.getElementName(); |
| final int c1type= (element.getElementType() & IModelElement.MASK_C1); |
| final boolean isRich= (c1type == IModelElement.C1_METHOD); |
| if ((isRich || c1type == IModelElement.C1_VARIABLE) |
| && isCompletable(elementName) |
| && pattern.matches(elementName.getSegmentName())) { |
| final int relevance= iter.getRelevance(); |
| if ((relevance < 0) && !isRich |
| && mainNames.contains(elementName.getSegmentName()) ) { |
| continue; |
| } |
| final IAssistCompletionProposal proposal= createProposal(context, |
| offset, elementName, element, relevance ); |
| if (proposal != null) { |
| if (elementName.getNextSegment() == null) { |
| if (isRich) { |
| methodNames.add(elementName.getSegmentName()); |
| } |
| else { |
| mainNames.add(elementName.getSegmentName()); |
| } |
| } |
| proposals.add(proposal); |
| } |
| } |
| } |
| } |
| |
| mainNames.addAll(methodNames); |
| for (final RFrameIterator iter= this.searchPath.iterator(); iter.hasNext();) { |
| final IRFrame envir= iter.next(); |
| if (envir instanceof IRFrameInSource) { |
| final IRFrameInSource sframe= (IRFrameInSource) envir; |
| final Set<String> elementNames= sframe.getAllAccessNames(); |
| for (final String candidate : elementNames) { |
| if (candidate != null |
| && pattern.matches(candidate) |
| && !mainNames.contains(candidate) |
| && !(candidate.equals(prefixSegmentName) |
| && (sframe.getAllAccessOf(candidate, false).size() <= 1) )) { |
| final IAssistCompletionProposal proposal= createProposal(context, |
| offset, candidate ); |
| if (proposal != null) { |
| mainNames.add(candidate); |
| proposals.add(proposal); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| private void doComputeKeywordProposals(final RAssistInvocationContext context, |
| final AssistProposalCollector proposals, |
| final IProgressMonitor monitor) { |
| final RElementName prefixName= context.getIdentifierElementName(); |
| final String prefixSegmentName= nonNullAssert(prefixName.getSegmentName()); |
| |
| if (prefixName.getScope() != null) { |
| return; |
| } |
| |
| final String prefixSource= context.getIdentifierPrefix(); |
| if (!prefixSegmentName.isEmpty() && prefixSource.charAt(0) != '`') { |
| final int offset= context.getIdentifierOffset(); |
| final List<String> keywords= fgKeywords; |
| for (final String keyword : keywords) { |
| if (keyword.regionMatches(true, 0, prefixSegmentName, 0, prefixSegmentName.length())) { |
| proposals.add(new RKeywordCompletionProposal(context, keyword, offset)); |
| } |
| } |
| } |
| } |
| |
| protected void doComputeSubProposals(final RAssistInvocationContext context, |
| final RAstNode node, |
| final AssistProposalCollector proposals, |
| final IProgressMonitor monitor) { |
| final RElementName prefixName= context.getIdentifierElementName(); |
| |
| this.searchPath.init(context, node, getSearchMode(context), prefixName.getScope()); |
| |
| int count= 0; |
| final String namePrefix; |
| { RElementName prefixSegment= prefixName; |
| while (true) { |
| count++; |
| if (prefixSegment.getNextSegment() != null) { |
| prefixSegment= prefixSegment.getNextSegment(); |
| continue; |
| } |
| else { |
| break; |
| } |
| } |
| namePrefix= (prefixSegment.getSegmentName() != null) ? |
| prefixSegment.getSegmentName() : ""; //$NON-NLS-1$ |
| } |
| final RSymbolComparator.PrefixPattern pattern= new RSymbolComparator.PrefixPattern(namePrefix); |
| final int offset= context.getIdentifierLastSegmentOffset(); |
| |
| final Set<String> mainNames= new HashSet<>(); |
| final List<String> methodNames= new ArrayList<>(); |
| |
| for (final RFrameIterator iter= this.searchPath.iterator(); iter.hasNext();) { |
| final IRFrame envir= iter.next(); |
| |
| final List<? extends IRLangElement> elements= envir.getModelChildren(null); |
| ITER_ELEMENTS: for (final IRLangElement rootElement : elements) { |
| final RElementName elementName= rootElement.getElementName(); |
| final int c1type= (rootElement.getElementType() & IModelElement.MASK_C1); |
| final boolean isRich= (c1type == IModelElement.C1_METHOD); |
| if (isRich || c1type == IModelElement.C1_VARIABLE) { |
| IRLangElement element= rootElement; |
| RElementName prefixSegment= prefixName; |
| RElementName elementSegment= elementName; |
| ITER_SEGMENTS: for (int i= 0; i < count-1; i++) { |
| if (elementSegment == null) { |
| final List<? extends IRLangElement> children= getChildren(context, element); |
| for (final IRLangElement child : children) { |
| elementSegment= child.getElementName(); |
| if (isCompletable(elementSegment) |
| && elementSegment.getSegmentName().equals(prefixSegment.getSegmentName())) { |
| element= child; |
| prefixSegment= prefixSegment.getNextSegment(); |
| elementSegment= elementSegment.getNextSegment(); |
| continue ITER_SEGMENTS; |
| } |
| } |
| continue ITER_ELEMENTS; |
| } |
| else { |
| if (isCompletable(elementSegment) |
| && elementSegment.getSegmentName().equals(prefixSegment.getSegmentName())) { |
| prefixSegment= prefixSegment.getNextSegment(); |
| elementSegment= elementSegment.getNextSegment(); |
| continue ITER_SEGMENTS; |
| } |
| continue ITER_ELEMENTS; |
| } |
| } |
| |
| final boolean childMode; |
| final List<? extends IRLangElement> children; |
| if (elementSegment == null) { |
| childMode= true; |
| children= getChildren(context, element); |
| } |
| else { |
| childMode= false; |
| children= Collections.singletonList(element); |
| } |
| for (final IRLangElement child : children) { |
| if (childMode) { |
| elementSegment= child.getElementName(); |
| } |
| final String candidate= elementSegment.getSegmentName(); |
| final int relevance= iter.getRelevance(); |
| if (isCompletable(elementSegment) |
| && pattern.matches(candidate) ) { |
| if ((relevance > 0) && !isRich |
| && mainNames.contains(candidate) ) { |
| continue ITER_ELEMENTS; |
| } |
| final IAssistCompletionProposal proposal= createProposal(context, |
| offset, elementSegment, child, relevance ); |
| if (proposal != null) { |
| if (elementSegment.getNextSegment() == null) { |
| if (isRich) { |
| methodNames.add(candidate); |
| } |
| else { |
| mainNames.add(candidate); |
| } |
| } |
| proposals.add(proposal); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| mainNames.addAll(methodNames); |
| for (final RFrameIterator iter= this.searchPath.iterator(); iter.hasNext();) { |
| final IRFrame envir= iter.next(); |
| if (envir instanceof IRFrameInSource) { |
| final IRFrameInSource sframe= (IRFrameInSource) envir; |
| final List<? extends RElementAccess> allAccess= sframe.getAllAccessOf( |
| prefixName.getSegmentName(), true ); |
| if (allAccess != null) { |
| ITER_ELEMENTS: for (final RElementAccess elementAccess : allAccess) { |
| RElementAccess elementSegment= elementAccess; |
| RElementName prefixSegment= prefixName; |
| ITER_SEGMENTS: for (int i= 0; i < count - 1; i++) { |
| if (isCompletable(elementSegment) |
| && elementSegment.getSegmentName().equals(prefixSegment.getSegmentName())) { |
| prefixSegment= prefixSegment.getNextSegment(); |
| elementSegment= elementSegment.getNextSegment(); |
| continue ITER_SEGMENTS; |
| } |
| continue ITER_ELEMENTS; |
| } |
| |
| if (elementSegment == null || elementSegment.isSlave()) { |
| continue ITER_ELEMENTS; |
| } |
| final String candidate= elementSegment.getSegmentName(); |
| if (candidate != null && isCompletable(elementSegment) |
| && pattern.matches(candidate) |
| && !mainNames.contains(candidate) |
| && !candidate.equals(namePrefix) ) { |
| final IAssistCompletionProposal proposal= createProposal(context, |
| offset, candidate ); |
| if (proposal != null) { |
| mainNames.add(candidate); |
| proposals.add(proposal); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| protected IAssistCompletionProposal createProposal(final RAssistInvocationContext context, |
| final int offset, final String name) { |
| return new RSimpleCompletionProposal(context, name, offset); |
| } |
| |
| protected IAssistCompletionProposal createProposal(final RAssistInvocationContext context, |
| final int offset, final RElementName elementName, final IRElement element, |
| final int relevance) { |
| return new RElementCompletionProposal(context, elementName, offset, element, relevance, |
| this.labelProvider ); |
| } |
| |
| public void doComputeContextProposals(final RAssistInvocationContext context, |
| final AssistProposalCollector proposals, final IProgressMonitor monitor) { |
| if (context.getModelInfo() == null) { |
| return; |
| } |
| |
| final RAssistInvocationContext.FCallInfo fCallInfo= context.getFCallInfo(); |
| if (fCallInfo != null) { |
| final FCallNamePattern pattern= new FCallNamePattern(fCallInfo.getAccess()) { |
| |
| final int infoOffset= Math.max(fCallInfo.getNode().getArgsOpenOffset() + 1, 0); |
| |
| @Override |
| protected void handleMatch(final IRMethod element, final IRFrame frame, |
| final RFrameIterator iterator) { |
| proposals.add(new RElementCompletionProposal.ContextInformationProposal(context, |
| element.getElementName(), this.infoOffset, element, |
| iterator.getRelevance(), |
| RElementCompletionComputer.this.labelProvider )); |
| } |
| }; |
| pattern.searchFDef(fCallInfo.getSearchPath(getSearchMode(context))); |
| } |
| } |
| |
| |
| protected final boolean isPackageArg(final String name) { |
| return ("package".equals(name)); |
| } |
| |
| private void doComputeFCallArgumentProposals(final RAssistInvocationContext context, |
| final FCallInfo fCallInfo, final int argIdx, final boolean argName, final boolean argValue, |
| final AssistProposalCollector proposals) { |
| final RElementName prefixName= context.getIdentifierElementName(); |
| final String prefixSegmentName= nonNullAssert(prefixName.getSegmentName()); |
| |
| final int offset= context.getIdentifierOffset(); |
| |
| if (argValue && !argName) { |
| final FCall.Arg arg= fCallInfo.getArg(argIdx); |
| if (arg != null && arg.hasName()) { |
| if (this.inString && isPackageArg(arg.getNameChild().getText())) { |
| this.pkgNamePrio= ARG_TYPE_PRIO; |
| } |
| } |
| } |
| |
| class FCallHandler extends FCallNamePattern { |
| |
| private final RCoreFunctions coreFunction; |
| |
| private final HashSet<String> argNames= new HashSet<>(); |
| |
| private int matchCount; |
| |
| |
| FCallHandler() { |
| super(fCallInfo.getAccess()); |
| |
| if (fCallInfo.getAccess().getNextSegment() == null) { |
| this.coreFunction= RCoreFunctions.DEFAULT; |
| } |
| else { |
| this.coreFunction= null; |
| } |
| } |
| |
| |
| private boolean isValidNameContext(final ArgsDefinition.Arg argDef) { |
| if (RElementCompletionComputer.this.inString) { |
| return ((argDef.type & ArgsDefinition.NAME_AS_STRING) != 0); |
| } |
| else { |
| return ((argDef.type & ArgsDefinition.NAME_AS_SYMBOL) != 0); |
| } |
| } |
| |
| private boolean checkArgsDef(final FCallArgMatch args, |
| final boolean guess, final int relevance) { |
| final ArgsDefinition.Arg argDef= args.getArgDef(argIdx); |
| if (argDef != null) { |
| final boolean typedDef= (argDef.type != 0); |
| if (RElementCompletionComputer.this.pkgNamePrio == NA_PRIO) { |
| if (typedDef) { |
| if ((argDef.type & ArgsDefinition.PACKAGE_NAME) != 0 |
| && isValidNameContext(argDef) ) { |
| RElementCompletionComputer.this.pkgNamePrio= ARG_TYPE_PRIO + relevance; |
| } |
| } |
| else if (guess && RElementCompletionComputer.this.inString && isPackageArg(argDef.name)) { |
| RElementCompletionComputer.this.pkgNamePrio= ARG_TYPE_PRIO + relevance; |
| } |
| } |
| if (RElementCompletionComputer.this.helpTopicPrio == NA_PRIO) { |
| if (typedDef) { |
| if ((argDef.type & ArgsDefinition.HELP_TOPIC_NAME) != 0 |
| && isValidNameContext(argDef) ) { |
| RElementCompletionComputer.this.helpTopicPrio= ARG_TYPE_PRIO + relevance; |
| } |
| } |
| } |
| return typedDef; |
| } |
| return false; |
| } |
| |
| @Override |
| public void searchFDef(final RFrameSearchPath searchPath) { |
| super.searchFDef(searchPath); |
| |
| if (this.matchCount == 0 |
| && this.coreFunction != null) { |
| final FCall.Args callArgs= fCallInfo.getNode().getArgsChild(); |
| |
| final ArgsDefinition coreDef= this.coreFunction.getArgs( |
| getElementName().getSegmentName() ); |
| if (coreDef != null) { |
| checkArgsDef(RAst.matchArgs(callArgs, coreDef), false, 0); |
| } |
| } |
| } |
| |
| @Override |
| protected void handleMatch(final IRMethod element, final IRFrame frame, |
| final RFrameIterator iterator) { |
| final ArgsDefinition argsDef= element.getArgsDefinition(); |
| if (argsDef == null) { |
| return; |
| } |
| |
| this.matchCount++; |
| |
| final int relevance= iterator.getRelevance(); |
| if (argName) { |
| for (int i= 0; i < argsDef.size(); i++) { |
| final ArgsDefinition.Arg arg= argsDef.get(i); |
| if (arg.name != null && arg.name.length() > 0 && !arg.name.equals("...")) { |
| if ((prefixSegmentName == null || arg.name.startsWith(prefixSegmentName)) |
| && this.argNames.add(arg.name)) { |
| final RElementName name= RElementName.create(RElementName.MAIN_DEFAULT, arg.name); |
| proposals.add(new RElementCompletionProposal.ArgumentProposal( |
| context, name, offset, element, |
| ARG_NAME_PRIO + relevance, |
| RElementCompletionComputer.this.labelProvider )); |
| } |
| } |
| } |
| } |
| if (argValue) { |
| final FCall.Args callArgs= fCallInfo.getNode().getArgsChild(); |
| if (!checkArgsDef(RAst.matchArgs(callArgs, argsDef), true, relevance) |
| && frame.getFrameType() == IRFrame.PACKAGE |
| && this.coreFunction != null |
| && this.coreFunction.getPackageNames().contains(frame.getElementName().getSegmentName()) ) { |
| final ArgsDefinition coreDef= this.coreFunction.getArgs( |
| getElementName().getSegmentName() ); |
| if (coreDef != null) { |
| checkArgsDef(RAst.matchArgs(callArgs, coreDef), false, relevance); |
| } |
| } |
| } |
| } |
| |
| } |
| final FCallHandler search= new FCallHandler(); |
| search.searchFDef(fCallInfo.getSearchPath(getSearchMode(context))); |
| } |
| |
| |
| protected IRCoreAccess getRCoreAccess() { |
| return this.editor.getRCoreAccess(); |
| } |
| |
| protected final @Nullable RPkgManagerDataset getRPkgDataset() { |
| final IRPkgManager manager= RCore.getRPkgManager(getRCoreAccess().getREnv()); |
| if (manager != null) { |
| return manager.getDataset(); |
| } |
| return null; |
| } |
| |
| protected final boolean isPackageName(final RElementName elementName) { |
| return ((elementName.getType() == RElementName.MAIN_DEFAULT |
| || RElementName.isPackageFacetScopeType(elementName.getType()) ) |
| && elementName.getNextSegment() == null ); |
| } |
| |
| protected final void doComputePkgNameProposals(final RAssistInvocationContext context, |
| final int prio, final AssistProposalCollector proposals) { |
| final RElementName prefixName= context.getIdentifierElementName(); |
| final String prefixSegmentName= nonNullAssert(prefixName.getSegmentName()); |
| |
| if (prefixName.getScope() != null |
| || !isSymbolCandidate(prefixSegmentName)) { |
| return; |
| } |
| |
| final RPkgManagerDataset rPkgDataset= getRPkgDataset(); |
| |
| final PrefixPattern pattern= new RSymbolComparator.PrefixPattern(prefixSegmentName); |
| final int offset= context.getInvocationOffset() - prefixSegmentName.length(); |
| |
| final Collection<String> envNames; |
| if (rPkgDataset != null) { |
| final RPkgCompilation<? extends RPkgBuilt> pkgs= rPkgDataset.getInstalled(); |
| envNames= pkgs.getNames(); |
| for (final String pkgName : envNames) { |
| if (pattern.matches(pkgName)) { |
| proposals.add(new RElementCompletionProposal.RPkgProposal(context, |
| RElementName.create(RElementName.SCOPE_PACKAGE, pkgName), offset, |
| pkgs.getFirst(pkgName), prio )); |
| } |
| } |
| } |
| else { |
| envNames= ImCollections.emptySet(); |
| } |
| |
| final Set<String> workspaceNames= RModel.getRModelManager().getPkgNames(); |
| for (final String pkgName : workspaceNames) { |
| if (!envNames.contains(pkgName) && pattern.matches(pkgName)) { |
| proposals.add(new RElementCompletionProposal.RPkgProposal(context, |
| RElementName.create(RElementName.SCOPE_PACKAGE, pkgName), offset, |
| null, prio )); |
| } |
| } |
| } |
| |
| protected final void doComputeHelpTopicProposals(final RAssistInvocationContext context, |
| final String topicType, final RAstNode node, |
| final int prio, final AssistProposalCollector proposals) { |
| // (topic != null) => ? / (topic == null) => help() |
| final RElementName prefixName= context.getIdentifierElementName(); |
| final String prefixSegmentName= nonNullAssert(prefixName.getSegmentName()); |
| |
| if (topicType == null && (prefixName.getScope() != null || prefixSegmentName.isEmpty())) { |
| return; |
| } |
| |
| final REnv rEnv= getRCoreAccess().getREnv(); |
| if (rEnv == null) { |
| return; |
| } |
| |
| final Map<String, Object> matches= new HashMap<>(); |
| |
| final RHelpManager rHelpManager= RCore.getRHelpManager(); |
| |
| final REnvHelp help= rHelpManager.getHelp(rEnv); |
| if (help != null) { |
| try { |
| final PrefixPattern pattern= new RSymbolComparator.PrefixPattern(prefixSegmentName); |
| final BiFunction<Object, Object, Object> mergeFun= |
| (final Object oldValue, final Object newValue) -> { |
| List<Object> list; |
| if (oldValue instanceof List) { |
| list= (List<Object>) oldValue; |
| } |
| else { |
| list= new ArrayList<>(4); |
| list.add(oldValue); |
| } |
| list.add(newValue); |
| return list; |
| }; |
| this.searchPath.init(context, node, getSearchMode(context), prefixName.getScope()); |
| final Set<String> pkgNames= new HashSet<>(); |
| for (final IRFrame frame : this.searchPath) { |
| if (frame.getFrameType() == IRFrame.PACKAGE) { |
| final String pkgName= frame.getElementName().getSegmentName(); |
| if (pkgName != null && pkgNames.add(pkgName)) { |
| final RPkgHelp pkgHelp= help.getPkgHelp(pkgName); |
| if (pkgHelp != null) { |
| for (final RHelpTopicEntry topicEntry : pkgHelp.getTopics()) { |
| final String topic= topicEntry.getTopic(); |
| if (pattern.matches(topic)) { |
| matches.merge(topic, pkgName, mergeFun); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| finally { |
| help.unlock(); |
| } |
| } |
| |
| final int offset= (context.getInvocationContentType() != IRDocumentConstants.R_DEFAULT_CONTENT_TYPE) ? |
| context.getIdentifierLastSegmentOffset() + 1 : |
| context.getIdentifierLastSegmentOffset(); |
| for (final Map.Entry<String, Object> match : matches.entrySet()) { |
| proposals.add(new RSimpleCompletionProposal.RHelpTopicCompletionProposal( |
| context, match.getKey(), toString(match.getValue()), |
| offset, prio )); |
| } |
| } |
| |
| } |
