Java SharedASTProvider类代码示例

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
private static ForStatement getForStatement(ICompilationUnit cu) {
  CompilationUnit ast =
      SharedASTProvider.getAST(cu, SharedASTProvider.WAIT_YES, new NullProgressMonitor());

  final ForStatement[] statement = new ForStatement[1];
  ast.accept(
      new GenericVisitor() {
        protected boolean visitNode(ASTNode node) {
          if (node instanceof ForStatement) {
            statement[0] = (ForStatement) node;
            return false;
          } else {
            return super.visitNode(node);
          }
        }
      });

  return statement[0];
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
/**
 * Tries to get the shared AST from the ASTProvider. If the shared AST is not available, parses
 * the type root with a RefactoringASTParser that uses settings similar to the ASTProvider.
 *
 * @param typeRoot the type root
 * @param resolveBindings whether bindings are to be resolved if a new AST needs to be created
 * @param pm an {@link IProgressMonitor}, or <code>null</code>
 * @return the parsed CompilationUnit
 */
public static CompilationUnit parseWithASTProvider(
    ITypeRoot typeRoot, boolean resolveBindings, IProgressMonitor pm) {
  CompilationUnit cuNode =
      SharedASTProvider.getAST(typeRoot, SharedASTProvider.WAIT_ACTIVE_ONLY, pm);
  if (cuNode != null) {
    return cuNode;
  } else {
    return new RefactoringASTParser(ASTProvider.SHARED_AST_LEVEL)
        .parse(
            typeRoot,
            null,
            resolveBindings,
            ASTProvider.SHARED_AST_STATEMENT_RECOVERY,
            ASTProvider.SHARED_BINDING_RECOVERY,
            pm);
  }
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
@Override
protected void addEdits(IDocument doc, TextEdit root) throws CoreException {
  super.addEdits(doc, root);

  // build a full AST
  CompilationUnit unit =
      SharedASTProvider.getAST(getCompilationUnit(), SharedASTProvider.WAIT_YES, null);

  ASTNode name = NodeFinder.perform(unit, fOffset, fLength);
  if (name instanceof SimpleName) {

    SimpleName[] names = LinkedNodeFinder.findByProblems(unit, (SimpleName) name);
    if (names != null) {
      for (int i = 0; i < names.length; i++) {
        SimpleName curr = names[i];
        root.addChild(new ReplaceEdit(curr.getStartPosition(), curr.getLength(), fNewName));
      }
      return;
    }
  }
  root.addChild(new ReplaceEdit(fOffset, fLength, fNewName));
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
private NLSRefactoring(ICompilationUnit cu) {
	Assert.isNotNull(cu);
	fCu= cu;

	CompilationUnit astRoot= SharedASTProvider.getAST(fCu, SharedASTProvider.WAIT_YES, null);
	NLSHint nlsHint= new NLSHint(fCu, astRoot);

	fSubstitutions= nlsHint.getSubstitutions();
	setAccessorClassName(nlsHint.getAccessorClassName());
	setAccessorClassPackage(nlsHint.getAccessorClassPackage());

	setIsEclipseNLS(detectIsEclipseNLS());
	setResourceBundleName(nlsHint.getResourceBundleName());
	setResourceBundlePackage(nlsHint.getResourceBundlePackage());
	setSubstitutionPattern(DEFAULT_SUBST_PATTERN);

	String cuName= fCu.getElementName();
	if (fIsEclipseNLS)
		setPrefix(cuName.substring(0, cuName.length() - 5) + "_"); // A.java -> A_ //$NON-NLS-1$
	else
		setPrefix(cuName.substring(0, cuName.length() - 4)); // A.java -> A.
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
private CompilationUnit createAst(ICompilationUnit unit, Map<String, String> cleanUpOptions, IProgressMonitor monitor) {
	IJavaProject project= unit.getJavaProject();
	if (compatibleOptions(project, cleanUpOptions)) {
		CompilationUnit ast= SharedASTProvider.getAST(unit, SharedASTProvider.WAIT_NO, monitor);
		if (ast != null)
			return ast;
	}

	ASTParser parser= CleanUpRefactoring.createCleanUpASTParser();
	parser.setSource(unit);

	Map<String, String> compilerOptions= RefactoringASTParser.getCompilerOptions(unit.getJavaProject());
	compilerOptions.putAll(cleanUpOptions);
	parser.setCompilerOptions(compilerOptions);

	return (CompilationUnit)parser.createAST(monitor);
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
protected void installOccurrencesFinder(boolean forceUpdate) {
	fMarkOccurrenceAnnotations= true;

	fPostSelectionListenerWithAST= new ISelectionListenerWithAST() {
		public void selectionChanged(IEditorPart part, ITextSelection selection, CompilationUnit astRoot) {
			updateOccurrenceAnnotations(selection, astRoot);
		}
	};
	SelectionListenerWithASTManager.getDefault().addListener(this, fPostSelectionListenerWithAST);
	if (forceUpdate && getSelectionProvider() != null) {
		fForcedMarkOccurrencesSelection= getSelectionProvider().getSelection();
		ITypeRoot inputJavaElement= getInputJavaElement();
		if (inputJavaElement != null)
			updateOccurrenceAnnotations((ITextSelection)fForcedMarkOccurrencesSelection, SharedASTProvider.getAST(inputJavaElement, SharedASTProvider.WAIT_NO, getProgressMonitor()));
	}

	if (fOccurrencesFinderJobCanceler == null) {
		fOccurrencesFinderJobCanceler= new OccurrencesFinderJobCanceler();
		fOccurrencesFinderJobCanceler.install();
	}
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
/**
 * Opens and reveals the defining method.
 */
public void open() {
	CompilationUnit ast= SharedASTProvider.getAST(fJavaElement, SharedASTProvider.WAIT_ACTIVE_ONLY, null);
	if (ast != null) {
		ASTNode node= ast.findDeclaringNode(fAstNodeKey);
		if (node instanceof MethodDeclaration) {
			try {
				IMethodBinding methodBinding= ((MethodDeclaration)node).resolveBinding();
				IMethodBinding definingMethodBinding= Bindings.findOverriddenMethod(methodBinding, true);
				if (definingMethodBinding != null) {
					IJavaElement definingMethod= definingMethodBinding.getJavaElement();
					if (definingMethod != null) {
						JavaUI.openInEditor(definingMethod, true, true);
						return;
					}
				}
			} catch (CoreException e) {
				ExceptionHandler.handle(e, JavaEditorMessages.OverrideIndicatorManager_open_error_title, JavaEditorMessages.OverrideIndicatorManager_open_error_messageHasLogEntry);
				return;
			}
		}
	}
	String title= JavaEditorMessages.OverrideIndicatorManager_open_error_title;
	String message= JavaEditorMessages.OverrideIndicatorManager_open_error_message;
	MessageDialog.openError(JavaPlugin.getActiveWorkbenchShell(), title, message);
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
private CompilationUnit getRecoveredAST(IDocument document, int offset, Document recoveredDocument) {
	CompilationUnit ast= SharedASTProvider.getAST(fCompilationUnit, SharedASTProvider.WAIT_ACTIVE_ONLY, null);
	if (ast != null) {
		recoveredDocument.set(document.get());
		return ast;
	}

	char[] content= document.get().toCharArray();

	// clear prefix to avoid compile errors
	int index= offset - 1;
	while (index >= 0 && Character.isJavaIdentifierPart(content[index])) {
		content[index]= ' ';
		index--;
	}

	recoveredDocument.set(new String(content));

	final ASTParser parser= ASTParser.newParser(ASTProvider.SHARED_AST_LEVEL);
	parser.setResolveBindings(true);
	parser.setStatementsRecovery(true);
	parser.setSource(content);
	parser.setUnitName(fCompilationUnit.getElementName());
	parser.setProject(fCompilationUnit.getJavaProject());
	return (CompilationUnit) parser.createAST(new NullProgressMonitor());
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
@Override
public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
	if (!(getEditor() instanceof JavaEditor))
		return null;

	ITypeRoot je= getEditorInputJavaElement();
	if (je == null)
		return null;

	// Never wait for an AST in UI thread.
	CompilationUnit ast= SharedASTProvider.getAST(je, SharedASTProvider.WAIT_NO, null);
	if (ast == null)
		return null;

	ASTNode node= NodeFinder.perform(ast, offset, 1);
	if (node instanceof StringLiteral) {
		StringLiteral stringLiteral= (StringLiteral)node;
		return new Region(stringLiteral.getStartPosition(), stringLiteral.getLength());
	} else if (node instanceof SimpleName) {
		SimpleName simpleName= (SimpleName)node;
		return new Region(simpleName.getStartPosition(), simpleName.getLength());
	}

	return null;
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
private ICompletionProposal[] getJavaAnnotationFixes(IJavaAnnotation javaAnnotation) {
	ProblemLocation location= new ProblemLocation(position.getOffset(), position.getLength(), javaAnnotation);
	ICompilationUnit cu= javaAnnotation.getCompilationUnit();
	if (cu == null)
		return NO_PROPOSALS;

	ISourceViewer sourceViewer= null;
	if (viewer instanceof ISourceViewer)
		sourceViewer= (ISourceViewer) viewer;

	IInvocationContext context= new AssistContext(cu, sourceViewer, location.getOffset(), location.getLength(), SharedASTProvider.WAIT_ACTIVE_ONLY);
	if (!SpellingAnnotation.TYPE.equals(javaAnnotation.getType()) && !hasProblem(context.getASTRoot().getProblems(), location))
		return NO_PROPOSALS;

	ArrayList<IJavaCompletionProposal> proposals= new ArrayList<IJavaCompletionProposal>();
	JavaCorrectionProcessor.collectCorrections(context, new IProblemLocation[] { location }, proposals);
	Collections.sort(proposals, new CompletionProposalComparator());

	return proposals.toArray(new ICompletionProposal[proposals.size()]);
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
protected void doPropertyChanged(String property) {
	if (property.equals(PreferenceConstants.EDITOR_QUICKASSIST_LIGHTBULB)) {
		if (isSetInPreferences()) {
			ICompilationUnit cu= getCompilationUnit();
			if (cu != null) {
				installSelectionListener();
				Point point= fViewer.getSelectedRange();
				CompilationUnit astRoot= SharedASTProvider.getAST(cu, SharedASTProvider.WAIT_ACTIVE_ONLY, null);
				if (astRoot != null) {
					doSelectionChanged(point.x, point.y, astRoot);
				}
			}
		} else {
			uninstallSelectionListener();
		}
	}
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
@Override
protected void addEdits(IDocument doc, TextEdit root) throws CoreException {
	super.addEdits(doc, root);

	// build a full AST
	CompilationUnit unit= SharedASTProvider.getAST(getCompilationUnit(), SharedASTProvider.WAIT_YES, null);

	ASTNode name= NodeFinder.perform(unit, fOffset, fLength);
	if (name instanceof SimpleName) {

		SimpleName[] names= LinkedNodeFinder.findByProblems(unit, (SimpleName) name);
		if (names != null) {
			for (int i= 0; i < names.length; i++) {
				SimpleName curr= names[i];
				root.addChild(new ReplaceEdit(curr.getStartPosition(), curr.getLength(), fNewName));
			}
			return;
		}
	}
	root.addChild(new ReplaceEdit(fOffset, fLength, fNewName));
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
protected final IStatus calculateASTandInform(ITypeRoot input, ITextSelection selection, IProgressMonitor monitor) {
	if (monitor.isCanceled()) {
		return Status.CANCEL_STATUS;
	}
	// create AST
	try {
		CompilationUnit astRoot= SharedASTProvider.getAST(input, SharedASTProvider.WAIT_ACTIVE_ONLY, monitor);

		if (astRoot != null && !monitor.isCanceled()) {
			Object[] listeners;
			synchronized (PartListenerGroup.this) {
				listeners= fAstListeners.getListeners();
			}
			for (int i= 0; i < listeners.length; i++) {
				((ISelectionListenerWithAST) listeners[i]).selectionChanged(fPart, selection, astRoot);
				if (monitor.isCanceled()) {
					return Status.CANCEL_STATUS;
				}
			}
			return Status.OK_STATUS;
		}
	} catch (OperationCanceledException e) {
		// thrown when canceling the AST creation
	}
	return Status.CANCEL_STATUS;
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
/**
 * Returns the constant value for a field that is referenced by the currently active type.
 * This method does may not run in the main UI thread.
 * <p>
 * XXX: This method was part of the JavadocHover#getConstantValue(IField field, IRegion hoverRegion)
 * 		method (lines 299-314).
 * </p>
 * @param activeType the type that is currently active
 * @param field the field that is being referenced (usually not declared in <code>activeType</code>)
 * @param selection the region in <code>activeType</code> that contains the field reference
 * @param monitor a progress monitor
 *
 * @return the constant value for the given field or <code>null</code> if none
 * @since 3.4
 */
private static Object getConstantValueFromActiveEditor(ITypeRoot activeType, IField field, ITextSelection selection, IProgressMonitor monitor) {
	Object constantValue= null;

	CompilationUnit unit= SharedASTProvider.getAST(activeType, SharedASTProvider.WAIT_ACTIVE_ONLY, monitor);
	if (unit == null)
		return null;

	ASTNode node= NodeFinder.perform(unit, selection.getOffset(), selection.getLength());
	if (node != null && node.getNodeType() == ASTNode.SIMPLE_NAME) {
		IBinding binding= ((SimpleName)node).resolveBinding();
		if (binding != null && binding.getKind() == IBinding.VARIABLE) {
			IVariableBinding variableBinding= (IVariableBinding)binding;
			if (field.equals(variableBinding.getJavaElement())) {
				constantValue= variableBinding.getConstantValue();
			}
		}
	}
	return constantValue;
}
 

import org.eclipse.jdt.ui.SharedASTProvider; //导入依赖的package包/类
public static IMember getMemberFromOffset(ITextEditor javaEditor, int offset) throws JavaModelException {
	ITypeRoot element= JavaUI.getEditorInputTypeRoot(javaEditor.getEditorInput());
	CompilationUnit ast = SharedASTProvider.getAST(element, SharedASTProvider.WAIT_YES, null);
	NodeFinder finder= new NodeFinder(ast, offset, 0);
	ASTNode node= finder.getCoveringNode();

	while(node != null) {
		if(node instanceof Initializer) {
			TypeDeclaration typeDeclaration = (TypeDeclaration) node.getParent();
			IType type = (IType) typeDeclaration.resolveBinding().getJavaElement();
			for(IInitializer initializer : type.getInitializers()) {
				if(node.getStartPosition() == initializer.getSourceRange().getOffset()
						&& Flags.isStatic(initializer.getFlags())) {
					return initializer;
				}
			}
		}
		if(node instanceof MethodDeclaration) {
			IMethodBinding binding = ((MethodDeclaration) node).resolveBinding();
			return (IMethod) binding.getJavaElement();
		}
		node = node.getParent();
	}
	return null;
}