Java 类org.eclipse.emf.ecore.resource.Resource.Diagnostic 实例源码

@Override
public void analyse(Script script, String codeName, String code) {
    List<Diagnostic> errors = super.getScriptErrors(script);
    if (errors.isEmpty()) {
        String msg = "expected errors in " + codeName + " but there was not a single one";
        if (this.logger.isDebugEnabled()) {
            StringBuilder sb = new StringBuilder(msg).append("\n");
            sb.append("========== " + codeName + " ==========\n");
            if (this.logCode) {
                sb.append(code).append("\n");
            }
            sb.append("========================================").append("\n");
            this.logger.debug(sb);
        }
        assertEquals(msg, code, codeName);
    }
}

@Override
protected List<Diagnostic> getScriptErrors(Script script) {
    EcoreUtil.resolveAll(script.eResource());
    List<Diagnostic> diagnostics = super.getScriptErrors(script);
    Iterator<Expression> expressions = Iterators.filter(EcoreUtil2.eAll(script), Expression.class);
    List<Diagnostic> result = Lists.<Diagnostic> newArrayList(Iterables.filter(diagnostics,
            ExceptionDiagnostic.class));
    while (expressions.hasNext()) {
        Expression expression = expressions.next();
        RuleEnvironment ruleEnvironment = RuleEnvironmentExtensions.newRuleEnvironment(expression);
        Result<TypeRef> type = typeSystem.type(ruleEnvironment, expression);
        if (type.getRuleFailedException() != null) {
            Throwable cause = Throwables.getRootCause(type.getRuleFailedException());
            if (!(cause instanceof RuleFailedException)) {
                if (cause instanceof Exception) {
                    result.add(new ExceptionDiagnostic((Exception) cause));
                } else {
                    throw new RuntimeException(cause);
                }
            }
        }
    }
    validator.validate(script.eResource(), CheckMode.ALL, CancelIndicator.NullImpl);
    return result;
}

@SuppressWarnings("javadoc")
@Test
public void testLoadingBuiltInTypes() {
    BuiltInTypeScope scope = BuiltInTypeScope.get(resourceSet);
    IEObjectDescription anyType = scope.getSingleElement(QualifiedName.create("any"));
    Assert.assertNotNull(anyType);
    String s = "";
    for (Resource resource : resourceSet.getResources()) {
        if (resource.getErrors().size() > 0) {
            for (Diagnostic d : resource.getErrors()) {
                s += "\n  " + d.getMessage() + " at " + resource.getURI() + ":" + d.getLine();
            }
        }
    }

    Assert.assertEquals("Resources definine built-in types must have no error."
            , "", s);
}

@Override
public void applyToModel(IResolvedTypes resolvedTypes) {
    Resource resource = getExpression().eResource();
    if (resource instanceof LazyLinkingResource) {
        LazyLinkingResource lazyLinkingResource = (LazyLinkingResource) resource;

        TypeAwareLinkingDiagnosticContext context = new TypeAwareLinkingDiagnosticContext(this, resolvedTypes);
        DiagnosticMessage message = lazyLinkingResource.getDiagnosticMessageProvider()
                .getUnresolvedProxyMessage(context);
        if (message != null) {
            List<Resource.Diagnostic> diagnostics = getDiagnosticList(lazyLinkingResource, message);
            Diagnostic diagnostic = createDiagnostic(message);
            diagnostics.add(diagnostic);
        }
        EObject referenced = (InternalEObject) getExpression().eGet(getReference(), false);
        lazyLinkingResource.markUnresolvable(referenced);
    }
}

public final XtextResource getResourceAndExpect(InputStream in, URI uri, int expectedErrors) throws Exception {
    XtextResource resource = doGetResource(in, uri);
    checkNodeModel(resource);
    if (expectedErrors != UNKNOWN_EXPECTATION) {
        if (expectedErrors == EXPECT_ERRORS)
            assertFalse(Joiner.on('\n').join(resource.getErrors()), resource.getErrors().isEmpty());
        else
            assertEquals(Joiner.on('\n').join(resource.getErrors()), expectedErrors, resource.getErrors().size());
    }
    for(Diagnostic d: resource.getErrors()) {
        if (d instanceof ExceptionDiagnostic)
            fail(d.getMessage());
    }
    if (expectedErrors == 0 && resource.getContents().size() > 0 && shouldTestSerializer(resource)) {
        SerializerTestHelper tester = get(SerializerTestHelper.class);
        EObject obj = resource.getContents().get(0);
        tester.assertSerializeWithNodeModel(obj);
        tester.assertSerializeWithoutNodeModel(obj);
    }
    return resource;
}

@Override
public void convertResourceDiagnostic(Diagnostic diagnostic, Severity severity, IAcceptor<Issue> acceptor) {
    IssueImpl issue = new Issue.IssueImpl();
    issue.setSyntaxError(diagnostic instanceof XtextSyntaxDiagnostic);
    issue.setSeverity(severity);
    issue.setLineNumber(diagnostic.getLine());
    issue.setColumn(diagnostic.getColumn());
    issue.setMessage(diagnostic.getMessage());

    if (diagnostic instanceof org.eclipse.xtext.diagnostics.Diagnostic) {
        org.eclipse.xtext.diagnostics.Diagnostic xtextDiagnostic = (org.eclipse.xtext.diagnostics.Diagnostic) diagnostic;
        issue.setOffset(xtextDiagnostic.getOffset());
        issue.setLength(xtextDiagnostic.getLength());
    }
    if (diagnostic instanceof AbstractDiagnostic) {
        AbstractDiagnostic castedDiagnostic = (AbstractDiagnostic)diagnostic;
        issue.setUriToProblem(castedDiagnostic.getUriToProblem());
        issue.setCode(castedDiagnostic.getCode());
        issue.setData(castedDiagnostic.getData());
    }
    issue.setType(CheckType.FAST);
    acceptor.accept(issue);
}

/**
 * @since 2.4
 */
protected String[] getIssueData(org.eclipse.emf.common.util.Diagnostic diagnostic) {
    if (diagnostic instanceof AbstractValidationDiagnostic) {
        AbstractValidationDiagnostic diagnosticImpl = (AbstractValidationDiagnostic) diagnostic;
        return diagnosticImpl.getIssueData();
    } else {
        // replace any EObjects by their URIs
        EObject causer = getCauser(diagnostic);
        List<String> issueData = newArrayList();
        for (Object object : diagnostic.getData()) {
            if (object != causer && object instanceof EObject) {
                EObject eObject = (EObject)object;
                issueData.add(EcoreUtil.getURI(eObject).toString());
            } else if (object instanceof String) {
                issueData.add( (String) object);
            }
        }
        return issueData.toArray(new String[issueData.size()]);
    }
}

@Test public void testAbstractLanguageToMetamodel() throws Exception {
    XtextResource r = getResource("classpath:/" + AbstractTestLanguage.class.getName().replace('.', '/') + ".xtext");
    Grammar element = (Grammar) r.getParseResult().getRootASTElement();
    if (!r.getErrors().isEmpty()) {
        EList<Diagnostic> errors = r.getErrors();
        for (Diagnostic syntaxError : errors) {
            logger.debug(syntaxError.getMessage() + " - " + syntaxError.getLine());
        }
        fail(errors.toString());
    }
    List<TerminalRule> lexerRules = GrammarUtil.allTerminalRules(element);
    assertEquals(8, lexerRules.size());

    List<EPackage> list = Xtext2EcoreTransformer.doGetGeneratedPackages(element);
    assertNotNull(list);
    assertEquals(0, list.size());
}

public final XtextResource getResourceAndExpect(InputStream in, URI uri, int expectedErrors) throws Exception {
    XtextResource resource = doGetResource(in, uri);
    checkNodeModel(resource);
    if (expectedErrors != UNKNOWN_EXPECTATION) {
        if (expectedErrors == EXPECT_ERRORS)
            assertFalse(Joiner.on('\n').join(resource.getErrors()), resource.getErrors().isEmpty());
        else
            assertEquals(Joiner.on('\n').join(resource.getErrors()), expectedErrors, resource.getErrors().size());
    }
    for(Diagnostic d: resource.getErrors()) {
        if (d instanceof ExceptionDiagnostic)
            fail(d.getMessage());
    }
    if (expectedErrors == 0 && resource.getContents().size() > 0 && shouldTestSerializer(resource)) {
        SerializerTestHelper tester = get(SerializerTestHelper.class);
        EObject obj = resource.getContents().get(0);
        tester.assertSerializeWithNodeModel(obj);
        tester.assertSerializeWithoutNodeModel(obj);
    }
    return resource;
}

private XExpression parseScriptIntoXTextEObject(String scriptAsString) throws ScriptParsingException {
    Resource resource = resourceSet.createResource(computeUnusedUri(resourceSet)); // IS-A XtextResource
    try {
        resource.load(new StringInputStream(scriptAsString), resourceSet.getLoadOptions());
    } catch (IOException e) {
        throw new ScriptParsingException("Unexpected IOException; from close() of a String-based ByteArrayInputStream, no real I/O; how is that possible???", scriptAsString, e);
    }

    List<Diagnostic> errors = resource.getErrors();
    if (errors.size() != 0) {
        throw new ScriptParsingException("Failed to parse expression (due to managed SyntaxError/s)", scriptAsString).addDiagnosticErrors(errors);
    }

    EList<EObject> contents = resource.getContents();

    if (!contents.isEmpty()) {
        Iterable<Issue> validationErrors = getValidationErrors(contents.get(0));
        if(!validationErrors.iterator().hasNext()) {
            return (XExpression) contents.get(0);
        } else {
            throw new ScriptParsingException("Failed to parse expression (due to managed ValidationError/s)", scriptAsString).addValidationIssues(validationErrors);
        }
    } else {
        return null;
    }
}

@Override
public void doSignal(List<Diagnostic> errors, int cursorColumn, int cursorLine) {
    for (Diagnostic e : errors) {
        if (e instanceof AbstractDiagnostic) {
            AbstractDiagnostic error = (AbstractDiagnostic) e;

            int errorLine = error.getLine();
            int errorBegin = error.getColumn();
            int errorLength = error.getLength();

            if (errorLine != cursorLine) {
                return;
            }
            doSignal(cursorColumn, cursorLine, errorBegin, errorLength);
        }
    }
    oldColumn = cursorColumn;
    oldLine = cursorLine;
}

@Override
protected void handleCursorPositionChanged() {
    super.handleCursorPositionChanged();
    IXtextDocument document = getDocument();
    CooperateXtextDocument cooperateXtextDocument = document.getAdapter(CooperateXtextDocument.class);
    if (cooperateXtextDocument.getResource() == null) {
        return;
    }
    EList<Diagnostic> errors = cooperateXtextDocument.getResource().getErrors();

    if (ErrorIndicatorPreferenceHandler.INSTANCE.getErrorAreaIndicatorSetting()) {
        areaErrorIndicator.doSignal(errors, getCursorPosition());
    }
    if (ErrorIndicatorPreferenceHandler.INSTANCE.getErrorLineIndicatorSetting()) {
        lineErrorIndicator.doSignal(errors, getCursorPosition());
    }
}

public ATLModel(Resource original, String fileLocation, boolean keepCopier) { 
    DynamicToStaticCopier copier = new DynamicToStaticCopier(fileLocation);
    ResourceSet rs = original.getResourceSet();
    if ( rs == null ) {
        rs = new ResourceSetImpl();
    }
    resource = rs.createResource(URI.createURI("trafo.ext"));       
    copier.copyResource(original, resource);

    if ( keepCopier ) {
        this.copierTrace = new ATLModelTrace(copier);
    }

    mainFileLocation = fileLocation;
    fileLocations.add(fileLocation);

    errors = new ErrorModel(resource);
    typing = new TypingModel(resource);

    hasSyntaxErrors = original.getErrors().size() > 0;
    if ( hasSyntaxErrors ) {
        for (Diagnostic diagnostic : original.getErrors()) {
            errors.signalParseError(diagnostic.getLocation(), diagnostic.getMessage(), diagnostic.getLine() + ":" + diagnostic.getColumn());
        }
    }
}

public static void extendWithPreconditions(ATLModel atlModel, List<String> preconditions, IAtlFileLoader loader) throws PreconditionParseError {
    if ( preconditions.size() > 0 ) {
        String text = "library preconditions;";
        int idx = 0;
        for (String pre : preconditions) {
            text = text + "\n-- @precondition \n" + "helper def: precondition_" + idx + " : Boolean = " + pre + ";"; 
            idx++;
        }

        Resource r = loader.load(text);
        String[] messages = new String[r.getErrors().size()];
        int i = 0;
        for (Diagnostic diagnostic : r.getErrors()) {
            messages[i] = diagnostic.toString();
            i++;
        }

        if ( r.getErrors().size() > 0 )
            throw new PreconditionParseError(messages);

        atlModel.extendWithPreconditions(r);
    }
}

private void removeAcceptedErrors(EList<Diagnostic> errors) {
    Iterator<Diagnostic> iterator = errors.iterator();
    while (iterator.hasNext()) {
        Resource.Diagnostic diagnostic = iterator.next();

        // removes errors for projectState and changePackage references in versions.
        if (diagnostic instanceof FeatureNotFoundException) {
            FeatureNotFoundException featureNotFoundException = (FeatureNotFoundException) diagnostic;
            if (featureNotFoundException.getObject() instanceof Version) {
                if (featureNotFoundException.getName().equals("projectState")
                    || featureNotFoundException.getName().equals("changes")) {
                    iterator.remove();
                }
            }
        }
    }
}

public void showErrors(XtextResource resource) {
    String error = "";
    if (! resource.getErrors().isEmpty()) {
        error += "### Parse: \n";
        for (Diagnostic d : resource.getErrors()) {
            error += d.getMessage() + " in " + d.getLine()  + "\n";

        }
    }
    if ( error.length() == 0 ) {
        System.out.println("Ok : " + resource.getContents());
    } else {
        System.out.println(error);
    }

}

public void showErrors(XtextResource resource) {
    String error = "";
    if (! resource.getErrors().isEmpty()) {
        error += "### Parse: \n";
        for (Diagnostic d : resource.getErrors()) {
            error += d.getMessage() + " in " + d.getLine()  + "\n";

        }
    }
    if ( error.length() == 0 ) {
        System.out.println("Ok : " + resource.getContents());
    } else {
        System.out.println(error);
    }

}

public void showErrors(XtextResource resource) {
    String error = "";
    if (! resource.getErrors().isEmpty()) {
        error += "### Parse: \n";
        for (Diagnostic d : resource.getErrors()) {
            error += d.getMessage() + " in " + d.getLine()  + "\n";

        }
    }
    if ( error.length() == 0 ) {
        System.out.println("Ok : " + resource.getContents());
    } else {
        System.out.println(error);
    }

}

@Override
public R compile(String path) throws EclecticException, IOException {
    XtextResource r = parse(path, new FileInputStream(path));
    TaoTransformation t = (TaoTransformation) r.getContents().get(0);

    // TODO: DUPLICATED WITH KOANFRONTEND: MERGE
    if ( r.getErrors().size() > 0 ) {
        String str = "";
        EList<Diagnostic> errors = r.getErrors();
        for (Diagnostic diagnostic : errors) {
            str = str + diagnostic.toString() + "\n";
        }
        throw new EclecticException("Syntax errors: " + str);
    }

    FrontendUtil.setFilePathToElements(path, t);

    return next.compile(t);
}

@Override
public R compile(String path) throws EclecticException, IOException {
    XtextResource r = parse(path, new FileInputStream(path));
    MappingTransformation t = (MappingTransformation) r.getContents().get(0);

    // TODO: DUPLICATED WITH KOANFRONTEND: MERGE
    if ( r.getErrors().size() > 0 ) {
        String str = "";
        EList<Diagnostic> errors = r.getErrors();
        for (Diagnostic diagnostic : errors) {
            str = str + diagnostic.toString() + "\n";
        }
        throw new EclecticException("Syntax errors: " + str);
    }

    FrontendUtil.setFilePathToElements(path, t);

    return next.compile(t);
}

@Override
public R compile(String path) throws EclecticException {
    XtextResource r = parse(path, null);
    AttributionTransformation t = (AttributionTransformation) r.getContents().get(0);

    // TODO: DUPLICATED WITH KOANFRONTEND: MERGE
    if ( r.getErrors().size() > 0 ) {
        String str = "";
        EList<Diagnostic> errors = r.getErrors();
        for (Diagnostic diagnostic : errors) {
            str = str + diagnostic.toString() + "\n";
        }
        throw new EclecticException("Syntax errors: " + str);
    }

    FrontendUtil.setFilePathToElements(path, t);

    return next.compile(t);
}

@Override
public R compile(String path) throws EclecticException, IOException {
    XtextResource r = parse(path, new FileInputStream(path));
    ChainTransformation t = (ChainTransformation) r.getContents().get(0);

    // TODO: DUPLICATED WITH KOANFRONTEND: MERGE
    if ( r.getErrors().size() > 0 ) {
        String str = "";
        EList<Diagnostic> errors = r.getErrors();
        for (Diagnostic diagnostic : errors) {
            str = str + diagnostic.toString() + "\n";
        }
        throw new EclecticException("Syntax errors: " + str);
    }

    FrontendUtil.setFilePathToElements(path, t);

    return next.compile(t);
}

public R compile(String path, InputStream qoolS) throws EclecticException {
    XtextResource r = parse(path, qoolS);
    QoolTransformation t = (QoolTransformation) r.getContents().get(0);

    // TODO: DUPLICATED WITH KOANFRONTEND: MERGE
    if ( r.getErrors().size() > 0 ) {
        String str = "";
        EList<Diagnostic> errors = r.getErrors();
        for (Diagnostic diagnostic : errors) {
            str = str + diagnostic.toString() + "\n";
        }
        throw new EclecticException("Syntax errors: " + str);
    }

    // Set the path. For the moment I traverse every element so as not
    // to implement a complicated getFile() method

    FrontendUtil.setFilePathToElements(path, t);

    return next.compile(t);
}

public void showErrors(XtextResource resource) {
    String error = "";
    if (! resource.getErrors().isEmpty()) {
        error += "### Parse: \n";
        for (Diagnostic d : resource.getErrors()) {
            error += d.getMessage() + " in " + d.getLine()  + "\n";

        }
    }
    if ( error.length() == 0 ) {
        System.out.println("Ok : " + resource.getContents());
    } else {
        System.out.println(error);
    }

}

public void testConstant() throws IOException {
    StringConstant stringConstant = FjFactory.eINSTANCE.createStringConstant();
    stringConstant.setConstant("foobar");
    TypeResult typeResult = fixture.getType(stringConstant);
    assertTrue(typeResult.getBasicType() != null);
    assertEquals("String", AuxiliaryFunctions.getBasicType(typeResult.getType()).getBasic());

    IntConstant intConstant = FjFactory.eINSTANCE.createIntConstant();
    intConstant.setConstant(10);
    typeResult = fixture.getType(intConstant);
    assertTrue(typeResult.getBasicType() != null);
    assertEquals("int", AuxiliaryFunctions.getBasicType(typeResult.getType()).getBasic());

    BoolConstant boolConstant = FjFactory.eINSTANCE.createBoolConstant();
    boolConstant.setConstant("true");
    typeResult = fixture.getType(boolConstant);
    assertTrue(typeResult.getBasicType() != null);
    assertEquals("boolean", AuxiliaryFunctions.getBasicType(typeResult.getType()).getBasic());

    Resource resource = loadFromString
        ("class A { int m() { return 10; } boolean n() {return false;} String p() { return \"foo\";}}");
    EList<Diagnostic> errors = resource.getErrors();
    assertTrue(errors.size() == 0);
}

public void generate() {
    ModelLoader modelLoader = prepareGeneratorEnvironment();
    for (Resource resource : modelLoader.getResources()) {
        if (resource.getErrors().size() > 0) {
            StringBuilder errorMsg = new StringBuilder();
            errorMsg.append("Error loading model " + resource.getURI().toString()
                    + ". The following errors occured: \n");
            for (Diagnostic error : resource.getErrors()) {
                errorMsg.append(error.getMessage());
            }
            logger.log(Level.SEVERE, errorMsg.toString());
            System.exit(-1);
        } else {
            generator.doGenerate(resource, outputFileSystem);
        }
    }
}

@Override
protected void invokeInternal(WorkflowContext ctx, ProgressMonitor monitor,
        Issues issues) {
    ResourceSet resourceSet = getResourceSet();

    // due to some Xcore peculiarity we have to access the IAllContainerState here
    // to trigger some lazy init logic
    IAllContainersState allContainerState = (IAllContainersState) EcoreUtil.getAdapter(resourceSet.eAdapters(),
            IAllContainersState.class);
    allContainerState.isEmpty("");

    Multimap<String, URI> uris = getPathTraverser().resolvePathes(pathes,
            new Predicate<URI>() {
        @Override
        public boolean apply(URI input) {
            return input.fileExtension().equals(XCORE_FILE_EXT);
        }
    });
    List<Resource> resources = new ArrayList<>();
    for (URI uri : uris.values()) {
        LOGGER.info(uri);
        try {
            resources.add(parse(uri, resourceSet));
        } catch (Exception e) {
            LOGGER.error("Problem during loading of resource @ " + uri, e);
        }
    }
    installIndex(resourceSet);
    for (Resource r : resources) {
        EcoreUtil.resolveAll(r);
        for (Diagnostic x : r.getErrors()) {
            issues.addError(x.getMessage(), x);
        }

    }
    ctx.set(slot, resources);
}

/**
 * Will only return parse errors, not validation errors!
 */
protected List<Resource.Diagnostic> getEditorErrors(XtextEditor fileXtextEditor) {
    return fileXtextEditor.getDocument().readOnly(new IUnitOfWork<List<Diagnostic>, XtextResource>() {

        @Override
        public List<Resource.Diagnostic> exec(XtextResource state) throws Exception {
            EcoreUtil.resolveAll(state);
            return state.getErrors();
        }
    });
}

@Override
public void analyse(Script script, String codeName, String code) {
    List<Diagnostic> errors = null;
    try {
        errors = getScriptErrors(script);
        // if (serializerTester != null) {
        // serializerTester.assertSerializeWithNodeModel(script);
        // }
    } catch (Throwable t) {
        StringWriter writer = new StringWriter();
        t.printStackTrace(new PrintWriter(writer));
        assertEquals(code, writer.toString());
        return;
    }
    if (!errors.isEmpty()) {
        String msg = "expected no errors in " + codeName + " but I got : " + errors.size();
        if (this.logger.isDebugEnabled()) {
            StringBuilder sb = new StringBuilder(msg).append("\n");
            sb.append("========== " + codeName + " ==========\n");
            if (this.logCode) {
                sb.append(code).append("\n");
            }
            sb.append(">>>> errors: ").append("\n");
            sb.append(this.aggregateDiagnosticsToStringBuilder(codeName, errors));
            sb.append(">>>> warnings: ").append("\n");
            sb.append("<<<<").append("\n");
            sb.append("========================================").append("\n");
            this.logger.debug(sb);
        }
        assertEquals(msg, withLineNumbers(code),
                this.aggregateDiagnosticsToStringBuilder(codeName, errors).toString());
    }
}

/***/
// TODO after java update bring back null analysis
// protected StringBuilder agregateDiagnosticsToStringBuilder(@Nonnull final List<Diagnostic> issues) {
protected StringBuilder aggregateDiagnosticsToStringBuilder(String codeName, final List<Diagnostic> issues) {
    StringBuilder result = new StringBuilder(codeName).append('\n');
    for (Diagnostic diagnostic : issues) {
        if (diagnostic instanceof ExceptionDiagnostic) {
            ((ExceptionDiagnostic) diagnostic).getException().printStackTrace();
        }
        result.append(" - line: " + diagnostic.getLine() + ", message: " + diagnostic.getMessage() + "\n");
    }
    return result;
}

/***/
// TODO after java update bring back null analysis
// protected List<Diagnostic> getScriptErrors(final @Nonnull Script script) {
protected List<Diagnostic> getScriptErrors(final Script script) {
    // may throw NPE
    return script.eResource().getErrors();
}

/**
 * Add the error to the resource of the given {@code context} if it does support validation.
 *
 * @param context
 *            the context object that caused the error.
 * @param node
 *            the error location.
 * @param error
 *            the actual error description.
 */
protected void addError(EObject context, INode node, IEObjectDescriptionWithError error) {
    N4JSResource resource = (N4JSResource) context.eResource();
    if (resource.isValidationDisabled())
        return;

    List<Diagnostic> list = resource.getErrors();

    // Convert key value user data to String array
    String[] userData = null;
    if (error.getUserDataKeys() != null) {
        ArrayList<String> userDataList = new ArrayList<>(error.getUserDataKeys().length * 2);
        for (String userDataKey : error.getUserDataKeys()) {
            final String userDataValue = error.getUserData(userDataKey);
            if (userDataValue != null) {
                userDataList.add(userDataKey);
                userDataList.add(userDataValue);
            }
        }
        userData = userDataList.toArray(new String[userDataList.size()]);
    }

    Diagnostic diagnostic = new XtextLinkingDiagnostic(node, error.getMessage(), error.getIssueCode(), userData);

    if (!list.contains(diagnostic))
        list.add(diagnostic);
}

protected Resource.Diagnostic createDiagnostic(DiagnosticMessage message) {
    Diagnostic diagnostic = new XtextLinkingDiagnostic(
            node, 
            message.getMessage(),
            message.getIssueCode(), message.getIssueData());
    return diagnostic;
}

protected List<Diagnostic> getDiagnosticList(LazyLinkingResource resource, /* @Nullable */ DiagnosticMessage message) throws AssertionError {
    if (message != null) {
        switch (message.getSeverity()) {
            case ERROR:
                return resource.getErrors();
            case WARNING:
                return resource.getWarnings();
            default:
                throw new AssertionError("Unexpected severity: " + message.getSeverity());
        }
    }
    return Collections.emptyList();
}

/**
 * To detect if there is error in SysML file, and return a error list
 * 
 * @param file
 *            file is the SysML which is going to test
 * @param resourceSet
 *            resourceSet is the EMF resourceSet
 * @return errorList errorList: a list of errors
 * @throws IOException
 * @throws ParserConfigurationException
 * @throws SAXException
 * @throws TransformerException
 */
public ArrayList<ErrorInfo> checkErrorAndGetErrorList(File file, ResourceSet resourceSet)
        throws IOException, ParserConfigurationException, SAXException, TransformerException {

    String method = "SysMLChecker_getErrorList(): ";
    long startTime = System.currentTimeMillis();
    MyLog.info(method + "start");

    URI uri = URI.createFileURI(file.getPath());
    ArrayList<ErrorInfo> errorLog = new ArrayList<ErrorInfo>();

    // load the resource into memory

    @SuppressWarnings("unused")
    Model umlModel = UML2Util.load(resourceSet, uri, UMLPackage.Literals.MODEL);
    // get all error list
    for (Resource umlResourceImpl : resourceSet.getResources()) {
        if (!umlResourceImpl.getErrors().isEmpty()) {
            for (Diagnostic error : umlResourceImpl.getErrors()) {
                ErrorInfo errorInfo = new ErrorInfo(error.getLine(), error.getColumn(), error.getMessage());
                if (!error.getMessage().contains("org.xml.sax.SAXParseException"))
                    // filter the sax exception errors
                    errorLog.add(errorInfo);
            }
        }
    }
    umlModel = null;

    MyLog.info(method + "end with " + (System.currentTimeMillis() - startTime) + " millisecond");
    MyLog.info();
    return errorLog;

}

@Override
public void convertValidatorDiagnostic(org.eclipse.emf.common.util.Diagnostic diagnostic,
        IAcceptor<Issue> acceptor) {
    Severity severity = getSeverity(diagnostic);
    if (severity == null)
        return;
    IssueImpl issue = new Issue.IssueImpl();
    issue.setSeverity(severity);

    IssueLocation locationData = getLocationData(diagnostic);
    if (locationData != null) {
        issue.setLineNumber(locationData.lineNumber);
        issue.setColumn(locationData.column);
        issue.setOffset(locationData.offset);
        issue.setLength(locationData.length);
    }
    final EObject causer = getCauser(diagnostic);
    if (causer != null)
        issue.setUriToProblem(EcoreUtil.getURI(causer));

    issue.setCode(getIssueCode(diagnostic));
    issue.setType(getIssueType(diagnostic));
    issue.setData(getIssueData(diagnostic));

    //      marker.put(IXtextResourceChecker.DIAGNOSTIC_KEY, diagnostic);
    issue.setMessage(diagnostic.getMessage());
    //      marker.put(IMarker.PRIORITY, Integer.valueOf(IMarker.PRIORITY_LOW));
    acceptor.accept(issue);
}

/**
 * @since 2.4
 */
protected CheckType getIssueType(org.eclipse.emf.common.util.Diagnostic diagnostic) {
    if (diagnostic instanceof AbstractValidationDiagnostic) {
        AbstractValidationDiagnostic diagnosticImpl = (AbstractValidationDiagnostic) diagnostic;
        return diagnosticImpl.getCheckType();
    } else {
        // default to FAST
        return CheckType.FAST;
    }
}

/**
 * @since 2.4
 */
protected String getIssueCode(org.eclipse.emf.common.util.Diagnostic diagnostic) {
    if (diagnostic instanceof AbstractValidationDiagnostic) {
        AbstractValidationDiagnostic diagnosticImpl = (AbstractValidationDiagnostic) diagnostic;
        return diagnosticImpl.getIssueCode();
    } else {
        return diagnostic.getSource() + "." + diagnostic.getCode();
    }
}

/**
 * @since 2.4
 */
protected Severity getSeverity(org.eclipse.emf.common.util.Diagnostic diagnostic) {
    if (diagnostic.getSeverity() == org.eclipse.emf.common.util.Diagnostic.OK)
        return null;
    switch (diagnostic.getSeverity()) {
        case org.eclipse.emf.common.util.Diagnostic.WARNING:
            return Severity.WARNING;
        case org.eclipse.emf.common.util.Diagnostic.INFO:
            return Severity.INFO;
        default :
            return Severity.ERROR;
    }
}

protected EObject getCauser(org.eclipse.emf.common.util.Diagnostic diagnostic) {
    // causer is the first element see Diagnostician.getData
    if (diagnostic.getData().isEmpty())
        return null;
    Object causer = diagnostic.getData().get(0);
    return causer instanceof EObject ? (EObject) causer : null;
}