import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
protected void performTestAnalysisTest(String className, int offset, Set<String> golden) throws Exception {
    prepareTest(className);

    DataObject od = DataObject.find(info.getFileObject());
    EditorCookie ec = (EditorCookie) od.getLookup().lookup(EditorCookie.class);

    Document doc = ec.openDocument();

    ChangeMethodParameters cmp = new ChangeMethodParameters();
    List<Fix> fixes = cmp.run(info, null, offset, null, null);
    Set<String> real = new HashSet<String>();

    for (Fix f : fixes) {
        if (f instanceof ChangeParametersFix) {
            real.add(((ChangeParametersFix) f).getText());
            continue;
        }
    }

    assertEquals(golden, real);
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
public boolean right() {
        Fix f = (Fix) getSelectedValue();
        Iterable<? extends Fix> subfixes = HintsControllerImpl.getSubfixes(f);

        if (subfixes.iterator().hasNext()) {
            Rectangle r = getCellBounds(getSelectedIndex(), getSelectedIndex());
            Point p = new Point(r.getLocation());
            SwingUtilities.convertPointToScreen(p, this);
            p.x += r.width;
//            p.y += r.height;
            HintsUI.getDefault().openSubList(subfixes, p);
            return true;
        }

        return false;
    }
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
@Override
   public List<Fix> run(CompilationInfo compilationInfo, String diagnosticKey, int offset, TreePath treePath, Data<Void> data) {
       EnumSet<Kind> supportedKinds = EnumSet.of(Kind.ANNOTATION_TYPE, Kind.CLASS, Kind.ENUM, Kind.VARIABLE, Kind.INTERFACE, Kind.METHOD);
       boolean isSupported = (supportedKinds.contains(treePath.getLeaf().getKind()));
if (!isSupported) {
    return null;
}
       String invalidMod = getInvalidModifier(compilationInfo, treePath, CODES);
       if (null==invalidMod)
       {
           return null;
       }

       //support multiple invalid modifiers
       Collection<Modifier> modss=convertToModifiers(invalidMod.split(","));
       TreePath modifierTreePath = TreePath.getPath(treePath, getModifierTree(treePath));
       Fix removeModifiersFix = FixFactory.removeModifiersFix(compilationInfo, modifierTreePath, new HashSet<>(modss), NbBundle.getMessage(RemoveInvalidModifier.class, "FIX_RemoveInvalidModifier", invalidMod, modss.size()));
       return Arrays.asList(removeModifiersFix);
   }
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
public void testSubFixesLeak() throws Exception {
    class TestFix implements Fix {
        @Override public String getText() { return null; }
        @Override public ChangeInfo implement() throws Exception { return null; }
    }

    Fix main = new TestFix();
    Fix sub  = new TestFix();

    HintsControllerImpl.attachSubfixes(main, Collections.singletonList(sub));

    Reference<Fix> mainRef = new WeakReference<Fix>(main);
    Reference<Fix> subRef = new WeakReference<Fix>(sub);

    main = null;
    sub = null;

    assertGC("main", mainRef);
    assertGC("sub", subRef);
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
public Collection<ErrorDescription> check(JPAProblemContext ctx, HintContext hc, AttributeWrapper attrib) {
    String temporal = attrib.getTemporal();

    if (temporal == null || temporal.length() == 0) {
        if (temporalTypes.contains(attrib.getType().toString())) {
            Fix fix = new CreateTemporalAnnotationHint(ctx.getFileObject(),
                    ElementHandle.create(attrib.getJavaElement()));

            Tree elementTree = ctx.getCompilationInfo().getTrees().getTree(attrib.getJavaElement());

            Utilities.TextSpan underlineSpan = Utilities.getUnderlineSpan(
                    ctx.getCompilationInfo(), elementTree);

            ErrorDescription error = ErrorDescriptionFactory.forSpan(
                    hc,
                    underlineSpan.getStartOffset(),
                    underlineSpan.getEndOffset(),
                    NbBundle.getMessage(TemporalFieldsAnnotated.class, "MSG_TemporalAttrNotAnnotatedProperly"),
                    fix);//TODO: may need to have "error" as default
            return Collections.singleton(error);
        }
    }

    return null;
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
@Hint(displayName = "#LBL_Empty_BLOCK", description = "#DSC_Empty_BLOCK", category = "empty", hintKind = Hint.Kind.INSPECTION, severity = Severity.VERIFIER, suppressWarnings = SUPPRESS_WARNINGS_KEY, id = "EmptyStatements_BLOCK")
@TriggerTreeKind(Tree.Kind.EMPTY_STATEMENT)
@NbBundle.Messages({"ERR_EmptyBLOCK=Remove semicolon"})
public static ErrorDescription forBLOCK(HintContext ctx) {

    Tree parent = ctx.getPath().getParentPath().getLeaf();
    if (!EnumSet.of(Kind.BLOCK).contains(parent.getKind())) {
        return null;
}

    final List<Fix> fixes = new ArrayList<>();
    fixes.add(FixFactory.createSuppressWarningsFix(ctx.getInfo(), ctx.getPath(), SUPPRESS_WARNINGS_KEY));
    fixes.add(JavaFixUtilities.removeFromParent(ctx, Bundle.ERR_EmptyBLOCK(), ctx.getPath()));

    return createErrorDescription(ctx, ctx.getPath().getLeaf(), fixes, Kind.BLOCK);
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
private static List<Fix> prepareCreateInnerClassFix(CompilationInfo info, TreePath invocation, TypeElement target, Set<Modifier> modifiers, String simpleName, List<? extends ExpressionTree> realArguments, TypeMirror superType, ElementKind kind, int numTypeParameters) {
       Pair<List<? extends TypeMirror>, List<String>> formalArguments = invocation != null ? Utilities.resolveArguments(info, invocation, realArguments, target) : Pair.<List<? extends TypeMirror>, List<String>>of(null, null);

       if (formalArguments == null) {
           return Collections.<Fix>emptyList();
       }

//IZ 111048 -- don't offer anything if target file isn't writable
if (!Utilities.isTargetWritable(target, info))
    return Collections.<Fix>emptyList();

       FileObject targetFile = SourceUtils.getFile(target, info.getClasspathInfo());

       if (targetFile == null)
           return Collections.<Fix>emptyList();
       final CreateInnerClassFix fix = new CreateInnerClassFix(info, simpleName, modifiers, target, formalArguments.first(), formalArguments.second(), superType, kind, numTypeParameters, targetFile);
       fix.setPriority(PRIO_INNER);
       return Collections.<Fix>singletonList(fix);
   }
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
public static ErrorDescription forName(HintContext context, Tree tree, String text, Fix... fixes) {
    int[] span;
    
    if (context.getHintMetadata().kind == Hint.Kind.INSPECTION) {
        span = computeNameSpan(tree, context);
    } else {
        span = new int[] {context.getCaretLocation(), context.getCaretLocation()};
    }
    
    if (span != null && span[0] != (-1) && span[1] != (-1)) {
        LazyFixList fixesForED = org.netbeans.spi.editor.hints.ErrorDescriptionFactory.lazyListForFixes(resolveDefaultFixes(context, fixes));
        return org.netbeans.spi.editor.hints.ErrorDescriptionFactory.createErrorDescription("text/x-java:" + context.getHintMetadata().id, context.getSeverity(), text, context.getHintMetadata().description, fixesForED, context.getInfo().getFileObject(), span[0], span[1]);
    }

    return null;
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
/** Creates a fix, which when invoked adds @SuppresWarnings(keys) to
 * nearest declaration.
 * @param compilationInfo CompilationInfo to work on
 * @param treePath TreePath to a tree. The method will find nearest outer
 *        declaration. (type, method, field or local variable)
 * @param keys keys to be contained in the SuppresWarnings annotation. E.g.
 *        @SuppresWarnings( "key" ) or @SuppresWarnings( {"key1", "key2", ..., "keyN" } ).
 * @throws IllegalArgumentException if keys are null or empty or id no suitable element
 *         to put the annotation on is found (e.g. if TreePath to CompilationUnit is given")
 */
static Fix createSuppressWarningsFix(CompilationInfo compilationInfo, TreePath treePath, String... keys ) {
    Parameters.notNull("compilationInfo", compilationInfo);
    Parameters.notNull("treePath", treePath);
    Parameters.notNull("keys", keys);

    if (keys.length == 0) {
        throw new IllegalArgumentException("key must not be empty"); // NOI18N
    }

    if (!isSuppressWarningsSupported(compilationInfo)) {
        return null;
    }

    while (treePath.getLeaf().getKind() != Kind.COMPILATION_UNIT && !DECLARATION.contains(treePath.getLeaf().getKind())) {
        treePath = treePath.getParentPath();
    }

    if (treePath.getLeaf().getKind() != Kind.COMPILATION_UNIT) {
        return new FixImpl(TreePathHandle.create(treePath, compilationInfo), compilationInfo.getFileObject(), keys);
    } else {
        return null;
    }
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
/** Creates a fix, which when invoked adds @SuppresWarnings(keys) to
 * nearest declaration.
 * @param compilationInfo CompilationInfo to work on
 * @param treePath TreePath to a tree. The method will find nearest outer
 *        declaration. (type, method, field or local variable)
 * @param keys keys to be contained in the SuppresWarnings annotation. E.g.
 *        @SuppresWarnings( "key" ) or @SuppresWarnings( {"key1", "key2", ..., "keyN" } ).
 * @throws IllegalArgumentException if keys are null or empty or id no suitable element
 *         to put the annotation on is found (e.g. if TreePath to CompilationUnit is given")
 */
static List<Fix> createSuppressWarnings(CompilationInfo compilationInfo, TreePath treePath, String... keys ) {
    Parameters.notNull("compilationInfo", compilationInfo);
    Parameters.notNull("treePath", treePath);
    Parameters.notNull("keys", keys);

    if (keys.length == 0) {
        throw new IllegalArgumentException("key must not be empty"); // NOI18N
    }

    Fix f = createSuppressWarningsFix(compilationInfo, treePath, keys);

    if (f != null) {
        return Collections.<Fix>singletonList(f);
    } else {
        return Collections.emptyList();
    }
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
private void performArithmeticTest(String orig, String nue) throws Exception {
    String code = replace("0");

    prepareTest("Test.java", code);
    ClassTree clazz = (ClassTree) info.getCompilationUnit().getTypeDecls().get(0);
    VariableTree variable = (VariableTree) clazz.getMembers().get(1);
    ExpressionTree init = variable.getInitializer();
    TreePath tp = new TreePath(new TreePath(new TreePath(new TreePath(info.getCompilationUnit()), clazz), variable), init);
    Fix fix = JavaFixUtilities.rewriteFix(info, "A", tp, orig, Collections.<String, TreePath>emptyMap(), Collections.<String, Collection<? extends TreePath>>emptyMap(), Collections.<String, String>emptyMap(), Collections.<String, TypeMirror>emptyMap(), Collections.<String, String>emptyMap());
    fix.implement();

    String golden = replace(nue);
    String out = doc.getText(0, doc.getLength());

    assertEquals(golden, out);

    LifecycleManager.getDefault().saveAll();
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
public void performRemoveFromParentTest(String code, String rule, String golden) throws Exception {
prepareTest("test/Test.java", code);

       HintDescription hd = HintDescriptionFactory.create()
                                                  .setTrigger(PatternDescription.create(rule, Collections.<String, String>emptyMap()))
                                                  .setWorker(new HintDescription.Worker() {
           @Override public Collection<? extends ErrorDescription> createErrors(HintContext ctx) {
               return Collections.singletonList(ErrorDescriptionFactory.forName(ctx, ctx.getPath(), "", JavaFixUtilities.removeFromParent(ctx, "", ctx.getPath())));
           }
       }).produce();

       List<ErrorDescription> computeHints = new HintsInvoker(HintsSettings.getGlobalSettings(), new AtomicBoolean()).computeHints(info, Collections.singleton(hd));

       assertEquals(computeHints.toString(), 1, computeHints.size());

       Fix fix = computeHints.get(0).getFixes().getFixes().get(0);

fix.implement();

       assertEquals(golden, doc.getText(0, doc.getLength()));
   }
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
@Hint(displayName = "#LBL_Empty_IF", description = "#DSC_Empty_IF", category = "empty", hintKind = Hint.Kind.INSPECTION, severity = Severity.VERIFIER, suppressWarnings = SUPPRESS_WARNINGS_KEY, id = "EmptyStatements_IF", enabled = false)
@TriggerTreeKind(Tree.Kind.EMPTY_STATEMENT)
public static ErrorDescription forIF(HintContext ctx) {
    final TreePath treePath = ctx.getPath();

    Tree parent = treePath.getParentPath().getLeaf();        
    if (!EnumSet.of(Kind.IF).contains(parent.getKind())) {
        return null;
    }
    
    TreePath treePathForWarning = treePath;
    IfTree it = (IfTree) parent;
    if (it.getThenStatement() != null
            && it.getThenStatement().getKind() == Tree.Kind.EMPTY_STATEMENT) {
        treePathForWarning = treePath.getParentPath();
            }
    if (it.getElseStatement() != null
            && it.getElseStatement().getKind() == Tree.Kind.EMPTY_STATEMENT) {
        treePathForWarning = treePath;
            }
    
    final List<Fix> fixes = new ArrayList<>();
    fixes.add(FixFactory.createSuppressWarningsFix(ctx.getInfo(), treePathForWarning, SUPPRESS_WARNINGS_KEY));
    
    return createErrorDescription(ctx, parent, fixes, parent.getKind());
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
protected void performAnalysisTest(String fileName, String code, int pos, String... golden) throws Exception {
    prepareTest(fileName, code);
    
    String diagnosticCode;
    
    if (pos == (-1)) {
        Diagnostic<?> d = findPositionForErrors();
        pos = (int) ErrorHintsProvider.getPrefferedPosition(info, d);
        diagnosticCode = d.getCode();
    } else {
        diagnosticCode = null;
    }
    
    TreePath path = info.getTreeUtilities().pathFor(pos);
    
    List<Fix> fixes = computeFixes(info, diagnosticCode, pos, path);
    List<String> fixesNames = new LinkedList<String>();
    
    fixes = fixes != null ? fixes : Collections.<Fix>emptyList();
    
    for (Fix e : fixes) {
        fixesNames.add(toDebugString(info, e));
    }
    
    assertTrue(fixesNames.toString(), Arrays.equals(golden, fixesNames.toArray(new String[0])));
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
@Override
public List<Fix> run(CompilationInfo info, String diagnosticKey, int offset, TreePath treePath, Data<Void> data) {
    if (treePath == null || !TreeUtilities.CLASS_TREE_KINDS.contains(treePath.getLeaf().getKind())) {
        return null;
    }
    if (treePath.getLeaf().getKind() == Tree.Kind.INTERFACE) {
        return null;
    }
    
    TypeElement type = (TypeElement) info.getTrees().getElement(treePath);
    if (type == null) {
        return null;
    }
    List<Fix> fixes = new ArrayList<Fix>();

    fixes.add(new FixImpl(TreePathHandle.create(treePath, info), false).toEditorFix());
    // fixes.add(new FixImpl(TreePathHandle.create(treePath, info), true));

    if (!type.getNestingKind().equals(NestingKind.ANONYMOUS)) {
        // add SuppressWarning only to non-anonymous class
        fixes.addAll(FixFactory.createSuppressWarnings(info, treePath, SERIAL));
    }

    return fixes;
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
public Fix fixFor(final HintContext ctx, ExecutableElement enclMethod, final TreePath tp) {
    CompilationInfo info = ctx.getInfo();
    
    assert info != null;
    assert tp != null;
    Element fe = info.getTrees().getElement(tp);
    if (fe == null) {
        return null;
    }
    String field = fe.getSimpleName().toString();
    final Types types = info.getTypes();
    final Elements elements = info.getElements();
    TypeMirror returnTypeEr = types.erasure(enclMethod.getReturnType());

    for (Entry<String, String> e : TO_UNMODIFIABLE.entrySet()) {
        TypeElement el = elements.getTypeElement(e.getKey());
        if (el != null && types.isSameType(returnTypeEr, types.erasure(el.asType()))) {
            return JavaFixUtilities.rewriteFix(ctx, NbBundle.getMessage(ReturnEncapsulation.class, "FIX_ReplaceWithUC",e.getValue(),field), tp, "java.util.Collections." + e.getValue() + "($expr)");
        }
    }
    return null;
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
public List<ErrorDescription> run(CompilationInfo compilationInfo,
                                  TreePath treePath) {
    int[] span = new int[2];
    List<Fix> fixes = computeFixes(compilationInfo, treePath, span);
    if (fixes == null) {
        return null;
    }

    ErrorDescription ed = ErrorDescriptionFactory.createErrorDescription(
        getSeverity().toEditorSeverity(),
        getDisplayName(),
        fixes,
        compilationInfo.getFileObject(),
        span[0],
        span[1]
    );

    return Collections.singletonList(ed);
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
@Hint(displayName = "#DN_CanBeFinal", description = "#DESC_CanBeFinal", category="thread", suppressWarnings="FieldMayBeFinal")
@TriggerTreeKind(Kind.VARIABLE)
public static ErrorDescription canBeFinal(HintContext ctx) {
    Element ve = ctx.getInfo().getTrees().getElement(ctx.getPath());
    
    if (ve == null || ve.getKind() != ElementKind.FIELD || ve.getModifiers().contains(Modifier.FINAL) || /*TODO: the point of volatile?*/ve.getModifiers().contains(Modifier.VOLATILE)) return null;
    
    //we can't say much currently about non-private fields:
    if (!ve.getModifiers().contains(Modifier.PRIVATE)) return null;
    
    FlowResult flow = Flow.assignmentsForUse(ctx);
    
    if (flow == null || ctx.isCanceled()) return null;
    
    if (flow.getFinalCandidates().contains(ve)) {
        VariableTree vt = (VariableTree) ctx.getPath().getLeaf();
        Fix fix = null;
        if (flow.getFieldInitConstructors(ve).size() <= 1) {
            fix = FixFactory.addModifiersFix(ctx.getInfo(), new TreePath(ctx.getPath(), vt.getModifiers()), EnumSet.of(Modifier.FINAL), Bundle.FIX_CanBeFinal(ve.getSimpleName().toString()));
        }
        return ErrorDescriptionFactory.forName(ctx, ctx.getPath(), Bundle.ERR_CanBeFinal(ve.getSimpleName().toString()), fix);
    }
    
    return null;
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
@Override
public List<Fix> run(CompilationInfo info, String diagnosticKey, int offset, TreePath treePath, Data<Void> data) {
    if (treePath.getLeaf().getKind() != Kind.ARRAY_ACCESS) {
        return Collections.emptyList();
    }
    ArrayAccessTree aa = (ArrayAccessTree) treePath.getLeaf();
    TypeMirror onType = info.getTrees().getTypeMirror(new TreePath(treePath, aa.getExpression()));
    boolean list = isSubType(info, onType, "java.util.List");
    boolean map = isSubType(info, onType, "java.util.Map");
    
    if (list || map) {
        Kind parentKind = treePath.getParentPath().getLeaf().getKind();
        if (CANNOT_HANDLE_PARENTS.contains(parentKind)) return null;
        return Collections.singletonList(new ConvertFromArrayAccess(info, treePath, map, parentKind == Kind.ASSIGNMENT).toEditorFix());
    }
    
    return Collections.emptyList();
}
 

import org.netbeans.spi.editor.hints.Fix; //导入依赖的package包/类
@Override
protected String toDebugString(CompilationInfo info, Fix f) {
    Object o = f;
    if (o instanceof JavaFixImpl) {
        o = ((JavaFixImpl)f).jf;
    }
    if (o instanceof DebugFix) {
        return ((DebugFix) o).toDebugString();
    } else if (o instanceof ImplementOnEnumValues2) {
        return "IOEV";
    } else 
    return super.toDebugString(info, f);
}