Example usage for org.eclipse.jdt.core.compiler IProblem getArguments

List of usage examples for org.eclipse.jdt.core.compiler IProblem getArguments

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.compiler.*
  5. IProblem
  6. getArguments

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.compiler IProblem getArguments.

Prototype

String[] getArguments();

Source Link

Document

Answer back the original arguments recorded into the problem.

Usage

From source file:com.microsoft.javapkgsrv.JavaParser.java

License:MIT License

public List<Problem> ProcessFileParseMessagesRequest(Integer fileId) {
    List<FileParseMessagesResponse.Problem> ret = new ArrayList<FileParseMessagesResponse.Problem>();
    if (ActiveUnits.containsKey(fileId)) {
        CompilationUnit cu = ActiveUnits.get(fileId);
        IProblem[] problems = cu.getProblems();

        for (IProblem problem : problems) {
            System.out.println(problem.toString());
            FileParseMessagesResponse.Problem.Builder retProblem = FileParseMessagesResponse.Problem
                    .newBuilder().setId(problem.getID()).setMessage(problem.getMessage())
                    .setFileName(new String(problem.getOriginatingFileName()))
                    .setScopeStart(problem.getSourceStart()).setScopeEnd(problem.getSourceEnd() + 1)
                    .setLineNumber(problem.getSourceLineNumber()).setProblemType(GetProblemType(problem));
            for (String arg : problem.getArguments())
                retProblem.addArguments(arg);
            ret.add(retProblem.build());
        }/*from  www  . j av a 2  s  .  c  om*/
    }
    return ret;
}

From source file:com.tsc9526.monalisa.plugin.eclipse.jdt.ProblemDetail.java

License:Open Source License

private String getDetail(IProblem problem) {
    StringBuilder sb = new StringBuilder();

    String className = new String(problem.getOriginatingFileName()).replace("/", ".");
    className = className.substring(0, className.length() - 5);
    String message = problem.getMessage();
    if (problem.getID() == IProblem.CannotImportPackage) {
        message = problem.getArguments()[0] + " cannot be resolved";
    }/*from ww  w.  ja v  a  2  s  .  c  om*/

    sb.append(className + ":" + message + ", Source: ");
    sb.append("\r\n==============================================\r\n");

    int start = problem.getSourceStart();
    int end = problem.getSourceEnd();
    char[] contents = result.getCompilationUnit().getContents();

    if (end > start && start >= 0 && end < contents.length) {
        int lineOffset = -1;
        for (int i = 0; i <= start; i++) {
            if (contents[i] == '\n') {
                lineOffset = -1;
            } else {
                lineOffset++;
            }
        }

        int lineStart = 0;
        for (int i = start; i < contents.length; i++) {
            if (contents[i] == '\n') {
                lineStart = i + 1;
                break;
            }
        }

        int minEnd = end;
        for (int i = start; i <= end; i++) {
            if (contents[i] == '\n') {
                minEnd = i;
                break;
            }
        }

        sb.append(new String(contents, 0, lineStart));

        for (int i = 0; i < lineOffset; i++) {
            sb.append(" ");
        }

        for (int i = 0; i <= (minEnd - start); i++) {
            sb.append("^");
        }

        sb.append(" <--- " + message + "\r\n");

        sb.append(new String(contents, lineStart, contents.length - lineStart));
    } else {
        sb.append(new String(contents));
    }

    sb.append("\r\n=====================================================\r\n");

    return sb.toString();
}

From source file:edu.brown.cs.bubbles.bedrock.BedrockProblem.java

License:Open Source License

private String[] getArguments(IProblem ip) {
    return ip.getArguments();
}

From source file:edu.brown.cs.bubbles.bedrock.BedrockUtil.java

License:Open Source License

/********************************************************************************/

static void outputProblem(IProject proj, IProblem ip, IvyXmlWriter xw) {
    xw.begin("PROBLEM");

    if (ip instanceof IMarker) {
        IMarker xmk = (IMarker) ip;/*from  w  ww  . j  av a2 s  . c  o  m*/
        xw.field("ID", xmk.getId());
    }

    xw.field("MSGID", ip.getID());
    xw.field("MESSAGE", ip.getMessage());
    char[] filc = ip.getOriginatingFileName();
    if (filc != null) {
        File fnm = new File(new String(filc));
        fnm = getFileForPath(fnm, proj);
        xw.field("FILE", fnm.getAbsolutePath());
    }
    xw.field("LINE", ip.getSourceLineNumber());
    xw.field("START", ip.getSourceStart());
    xw.field("END", ip.getSourceEnd());
    if (proj != null)
        xw.field("PROJECT", proj.getName());
    if (ip.isError())
        xw.field("ERROR", true);
    else {
        switch (ip.getID()) {
        case IProblem.Task:
            break;
        default:
            xw.field("WARNING", true);
            break;
        }
    }

    for (String s : ip.getArguments()) {
        xw.textElement("ARG", s);
    }

    BedrockPlugin.getPlugin().addFixes(ip, xw);

    xw.end("PROBLEM");
}

From source file:edu.uci.ics.sourcerer.extractor.ast.FeatureExtractor.java

License:Open Source License

public SourceExtractionReport extractSourceFiles(SourceExtractionReport report, Collection<IFile> sourceFiles,
        boolean force) {
    ReferenceExtractorVisitor visitor = new ReferenceExtractorVisitor(bundle);
    IMissingTypeWriter missingTypeWriter = bundle.getMissingTypeWriter();

    for (IFile source : sourceFiles) {
        ICompilationUnit icu = JavaCore.createCompilationUnitFrom(source);

        parser.setStatementsRecovery(true);
        parser.setResolveBindings(true);
        parser.setBindingsRecovery(true);
        parser.setSource(icu);//w ww.j ava  2  s . com

        CompilationUnit unit = null;
        try {
            unit = (CompilationUnit) parser.createAST(null);
        } catch (Exception e) {
            logger.log(Level.SEVERE, "Error in creating AST for " + source.getName(), e);
            report.reportSourceExtractionException();
            continue;
        }

        boolean secondOrder = checkForMissingTypes(unit, report, missingTypeWriter);
        if (!report.hadMissingType() || force) {
            if (secondOrder) {
                logger.warning("Performing limited extraction of " + source.getName()
                        + " because of missing second order type.");
                for (IProblem problem : unit.getProblems()) {
                    if (problem.getID() == IProblem.IsClassPathCorrect) {
                        logger.warning("  " + problem.getArguments()[0]);
                    }
                }
                visitor.setBindingFreeMode(true);
            }
            try {
                visitor.setCompilationUnitSource(icu.getSource());
                unit.accept(visitor);
                report.reportSourceExtraction();
            } catch (Exception e) {
                logger.log(Level.SEVERE, "Error in extracting " + source.getName(), e);
                report.reportSourceExtractionException();
            }
            visitor.setBindingFreeMode(false);
        }
    }
    return report;
}

From source file:edu.uci.ics.sourcerer.extractor.ast.FeatureExtractor.java

License:Open Source License

@SuppressWarnings("unchecked")
private boolean checkForMissingTypes(CompilationUnit unit, SourceExtractionReport report,
        IMissingTypeWriter writer) {/*from   w ww  . ja v  a  2 s. com*/
    Set<String> onDemandImports = Helper.newHashSet();
    Map<String, String> singleTypeImports = Helper.newHashMap();
    Set<String> simpleNames = Helper.newHashSet();

    boolean hasSecondOrder = false;
    // Check for the classpath problem
    for (IProblem problem : unit.getProblems()) {
        if (problem.isError()) {
            if (problem.getID() == IProblem.IsClassPathCorrect) {
                writer.writeMissingType(problem.getArguments()[0]);
                report.reportMissingSecondOrder();
                hasSecondOrder = true;
            } else if (problem.getID() == IProblem.ImportNotFound) {
                String prefix = problem.getArguments()[0];
                // Go and find all the imports with this prefix
                boolean found = false;
                for (ImportDeclaration imp : (List<ImportDeclaration>) unit.imports()) {
                    String fqn = imp.getName().getFullyQualifiedName();
                    if (fqn.startsWith(prefix)) {
                        if (imp.isOnDemand()) {
                            onDemandImports.add(fqn);
                        } else {
                            String simpleName = fqn.substring(fqn.lastIndexOf('.') + 1);
                            String oldFqn = singleTypeImports.get(simpleName);
                            if (oldFqn != null && !oldFqn.equals(fqn)) {
                                logger.log(Level.SEVERE,
                                        "Two fqns with the same simple name: " + fqn + " and " + oldFqn);
                            } else {
                                singleTypeImports.put(simpleName, fqn);
                            }
                        }
                        //              writer.writeMissingType(imp.getName().getFullyQualifiedName());
                        found = true;
                    }
                }
                if (!found) {
                    logger.log(Level.SEVERE, "Unable to find import matching: " + prefix);
                    writer.writeMissingType(prefix);
                }
                report.reportMissingType();
            } else if (problem.getID() == IProblem.UndefinedType) {
                simpleNames.add(problem.getArguments()[0]);
                report.reportMissingType();
            }
        }
    }

    for (String imp : onDemandImports) {
        writer.writeMissingType(imp);
    }
    for (String imp : singleTypeImports.values()) {
        writer.writeMissingType(imp);
    }
    for (String simpleName : simpleNames) {
        if (!singleTypeImports.containsKey(simpleName)) {
            for (String imp : onDemandImports) {
                writer.writeMissingType(imp + "." + simpleName);
            }
        }
    }
    return hasSecondOrder;
}

From source file:org.eclim.plugin.jdt.command.complete.CompletionProposalCollector.java

License:Open Source License

public void completionFailure(IProblem problem) {
    ICompilationUnit src = getCompilationUnit();
    IJavaProject javaProject = src.getJavaProject();
    IProject project = javaProject.getProject();

    // undefined type or attempting to complete static members of an unimported
    // type/*from w  w w .j  a v  a  2 s .  c om*/
    if (problem.getID() == IProblem.UndefinedType || problem.getID() == IProblem.UnresolvedVariable) {
        try {
            SearchPattern pattern = SearchPattern.createPattern(problem.getArguments()[0],
                    IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS,
                    SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE);
            IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { javaProject });
            SearchRequestor requestor = new SearchRequestor();
            SearchEngine engine = new SearchEngine();
            SearchParticipant[] participants = new SearchParticipant[] {
                    SearchEngine.getDefaultSearchParticipant() };
            engine.search(pattern, participants, scope, requestor, null);
            if (requestor.getMatches().size() > 0) {
                imports = new ArrayList<String>();
                for (SearchMatch match : requestor.getMatches()) {
                    if (match.getAccuracy() != SearchMatch.A_ACCURATE) {
                        continue;
                    }
                    IJavaElement element = (IJavaElement) match.getElement();
                    String name = null;
                    switch (element.getElementType()) {
                    case IJavaElement.TYPE:
                        IType type = (IType) element;
                        if (Flags.isPublic(type.getFlags())) {
                            name = type.getFullyQualifiedName();
                        }
                        break;
                    case IJavaElement.METHOD:
                    case IJavaElement.FIELD:
                        name = ((IType) element.getParent()).getFullyQualifiedName() + '.'
                                + element.getElementName();
                        break;
                    }
                    if (name != null) {
                        name = name.replace('$', '.');
                        if (!ImportUtils.isImportExcluded(project, name)) {
                            imports.add(name);
                        }
                    }
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    IResource resource = src.getResource();
    String relativeName = resource.getProjectRelativePath().toString();
    if (new String(problem.getOriginatingFileName()).endsWith(relativeName)) {
        String filename = resource.getLocation().toString();

        // ignore the problem if a temp file is being used and the problem is that
        // the type needs to be defined in its own file.
        if (problem.getID() == IProblem.PublicClassMustMatchFileName
                && filename.indexOf("__eclim_temp_") != -1) {
            return;
        }

        FileOffsets offsets = FileOffsets.compile(filename);
        int[] lineColumn = offsets.offsetToLineColumn(problem.getSourceStart());

        error = new Error(problem.getMessage(), filename.replace("__eclim_temp_", ""), lineColumn[0],
                lineColumn[1], problem.isWarning());
    }
}

From source file:org.eclim.plugin.jdt.command.correct.ProblemLocation.java

License:Open Source License

/**
 * Default Constructor.//w w w.java 2  s . c  o m
 */
public ProblemLocation(IProblem problem) {
    id = problem.getID();
    offset = problem.getSourceStart();
    length = (problem.getSourceEnd() + 1) - offset;
    arguments = problem.getArguments();
    error = problem.isError();
}

From source file:org.eclipse.ajdt.internal.ui.editor.CompilationUnitAnnotationModelWrapper.java

License:Open Source License

public void beginReporting() {
    if (delegate != null) {
        ((IProblemRequestor) delegate).beginReporting();

        IJavaProject project = unit.getJavaProject();

        AJCompilationUnitStructureRequestor requestor = new AJCompilationUnitStructureRequestor(unit,
                new AJCompilationUnitInfo(), new HashMap());
        JavaModelManager.PerWorkingCopyInfo perWorkingCopyInfo = ((CompilationUnit) unit)
                .getPerWorkingCopyInfo();
        boolean computeProblems = JavaProject.hasJavaNature(project.getProject()) && perWorkingCopyInfo != null
                && perWorkingCopyInfo.isActive();
        IProblemFactory problemFactory = new DefaultProblemFactory();
        Map options = project.getOptions(true);
        IBuffer buffer;//  w w w .  j  a v a 2 s .c  o  m
        try {
            buffer = unit.getBuffer();

            final char[] contents = buffer == null ? null : buffer.getCharacters();

            AJSourceElementParser parser = new AJSourceElementParser(requestor, problemFactory,
                    new CompilerOptions(options), true/*report local declarations*/, false);
            parser.reportOnlyOneSyntaxError = !computeProblems;

            parser.scanner.source = contents;
            requestor.setParser(parser);

            CompilationUnitDeclaration unitDec = parser.parseCompilationUnit(
                    new org.aspectj.org.eclipse.jdt.internal.compiler.env.ICompilationUnit() {
                        public char[] getContents() {
                            return contents;
                        }

                        public char[] getMainTypeName() {
                            return ((CompilationUnit) unit).getMainTypeName();
                        }

                        public char[][] getPackageName() {
                            return ((CompilationUnit) unit).getPackageName();
                        }

                        public char[] getFileName() {
                            return ((CompilationUnit) unit).getFileName();
                        }

                        public boolean ignoreOptionalProblems() {
                            return false;
                        }
                    }, true /*full parse to find local elements*/);
            org.aspectj.org.eclipse.jdt.core.compiler.IProblem[] problems = unitDec.compilationResult.problems;
            if (problems != null) {
                for (int i = 0; i < problems.length; i++) {
                    org.aspectj.org.eclipse.jdt.core.compiler.IProblem problem = problems[i];
                    if (problem == null)
                        continue;
                    ((IProblemRequestor) delegate)
                            .acceptProblem(
                                    new DefaultProblem(problem.getOriginatingFileName(), problem.getMessage(),
                                            problem.getID(), problem.getArguments(),
                                            problem.isError() ? ProblemSeverities.Error
                                                    : ProblemSeverities.Warning,
                                            problem.getSourceStart(), problem.getSourceEnd(),
                                            problem.getSourceLineNumber(), 0)); // unknown column
                }
            }
        } catch (JavaModelException e) {
        }
    }
}

From source file:org.eclipse.che.jdt.javaeditor.JavaReconciler.java

License:Open Source License

private Problem convertProblem(IProblem problem) {
    Problem result = DtoFactory.getInstance().createDto(Problem.class);

    result.setArguments(Arrays.asList(problem.getArguments()));
    result.setID(problem.getID());/*from ww w  .j  a va 2s .  c  om*/
    result.setMessage(problem.getMessage());
    result.setOriginatingFileName(new String(problem.getOriginatingFileName()));
    result.setError(problem.isError());
    result.setWarning(problem.isWarning());
    result.setSourceEnd(problem.getSourceEnd());
    result.setSourceStart(problem.getSourceStart());
    result.setSourceLineNumber(problem.getSourceLineNumber());

    return result;
}