import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Override
protected void createAndAddDiagnostic(Triple<EObject, EReference, INode> triple) {
	// check if unresolved reference is special case handled by {@link N4JSScopingDiagnostician}
	DiagnosticMessage scopingDiagnostic = scopingDiagnostician.getMessageFor(triple.getFirst(), triple.getSecond(),
			triple.getThird());
	// if so, use more specific diagnostic message
	if (null != scopingDiagnostic) {
		List<Diagnostic> list = getDiagnosticList(scopingDiagnostic);
		Diagnostic diagnostic = createDiagnostic(triple, scopingDiagnostic);
		if (!list.contains(diagnostic)) {
			list.add(diagnostic);
		}
	} else {
		// if not, use default generic scoping message
		super.createAndAddDiagnostic(triple);
	}
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@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);
	}
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Override
protected EObject handleCyclicResolution(Triple<EObject, EReference, INode> triple) throws AssertionError {
	if (!isValidationDisabled()) {
		EObject context = triple.getFirst();
		if (context.eClass() == TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE) {
			// here we may end up with cyclic resolution requests in rare situations, e.g. for input types
			// like :
			/*
			 * package p;
			 * class C extends p.C.Bogus {}
			 */
			return null;
		}
		DiagnosticMessage message = new DiagnosticMessage("Cyclic linking detected : " + getReferences(triple, resolving), Severity.ERROR, "cyclic-resolution");
		List<Diagnostic> list = getDiagnosticList(message);
		Diagnostic diagnostic = createDiagnostic(triple, message);
		if (!list.contains(diagnostic))
			list.add(diagnostic);
	}
	return null;
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Test
public void defaultModesOK() {
  ILinkingDiagnosticContext diagnosticContext = createMock(ILinkingDiagnosticContext.class);
  LexerCommand command = createMock(LexerCommand.class);
  LexerCommands commands = createMock(LexerCommands.class);

  expect(diagnosticContext.getLinkText()).andReturn("HIDDEN");
  expect(diagnosticContext.getContext()).andReturn(command);

  expect(command.eContainer()).andReturn(commands);

  Object[] mocks = {diagnosticContext, command, commands };

  replay(mocks);

  DiagnosticMessage message = new Antlr4MissingReferenceMessageProvider()
      .getUnresolvedProxyMessage(diagnosticContext);
  assertNull(message);

  verify(mocks);
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Test
public void undefinedMode() {
  ILinkingDiagnosticContext diagnosticContext = createMock(ILinkingDiagnosticContext.class);
  LexerCommand command = createMock(LexerCommand.class);
  LexerCommands commands = createMock(LexerCommands.class);

  expect(diagnosticContext.getLinkText()).andReturn("INSIDE");
  expect(diagnosticContext.getContext()).andReturn(command);

  expect(command.eContainer()).andReturn(commands);

  Object[] mocks = {diagnosticContext, command, commands };

  replay(mocks);

  DiagnosticMessage message = new Antlr4MissingReferenceMessageProvider()
      .getUnresolvedProxyMessage(diagnosticContext);
  assertNull(message);

  verify(mocks);
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
public DiagnosticMessage getUnresolvedProxyMessage(final ILinkingDiagnosticMessageProvider.ILinkingDiagnosticContext context) {
  EReference _reference = context.getReference();
  final EClass referenceType = _reference.getEReferenceType();
  String linkText = "";
  try {
    String _linkText = context.getLinkText();
    linkText = _linkText;
  } catch (final Throwable _t) {
    if (_t instanceof IllegalNodeException) {
      final IllegalNodeException e = (IllegalNodeException)_t;
      INode _node = e.getNode();
      String _text = _node.getText();
      linkText = _text;
    } else {
      throw Exceptions.sneakyThrow(_t);
    }
  }
  String _name = referenceType.getName();
  String _plus = ("Couldn\'t resolve reference to " + _name);
  String _plus_1 = (_plus + " \'");
  String _plus_2 = (_plus_1 + linkText);
  final String msg = (_plus_2 + "\'.");
  String _name_1 = referenceType.getName();
  DiagnosticMessage _diagnosticMessage = new DiagnosticMessage(msg, Severity.ERROR, Diagnostic.LINKING_DIAGNOSTIC, _name_1, linkText);
  return _diagnosticMessage;
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
/**
 * Creates a {@link DiagnosticMessage} for instanceof expressions where the right-hand-side is a primitive type
 * identifier.
 *
 * It is assumed that the given qualified name was extracted from the {@link IdentifierRef} on the rhs of the given
 * relational expression.
 *
 * Returns null if not applicable.
 *
 * @param name
 *            The unresolved name of an IdentifierRef on the RHS of the expression.
 *
 * @param expression
 *            A pair of the instanceof-expression and the unresolved IdentifierRef.
 */
@Override
DiagnosticMessage diagnose(QualifiedName name, RelationalExpression expression) {
	// only applicable for the instanceof operator
	if (expression.getOp() != RelationalOperator.INSTANCEOF) {
		return null;
	}

	// query built-in type scope for the unresolved name
	BuiltInTypeScope builtInTypeScope = BuiltInTypeScope.get(expression.eResource().getResourceSet());
	IEObjectDescription singleElement = builtInTypeScope.getSingleElement(name);

	// if there is no primitive type with this name, this diagnosis is not applicable
	if (null == singleElement) {
		return null;
	}

	// if we can find a primitive type for the qualified name
	if (singleElement.getEClass().getClassifierID() == TypesPackage.Literals.PRIMITIVE_TYPE.getClassifierID()) {
		// create special error message
		return createMessage(IssueCodes.TYS_INSTANCEOF_NOT_SUPPORTED_FOR_PRIMITIVE_TYPES,
				IssueCodes.getMessageForTYS_INSTANCEOF_NOT_SUPPORTED_FOR_PRIMITIVE_TYPES());
	} else {
		// the found element is not a primitive type, diagnosis not applicable
		return null;
	}

}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Override
DiagnosticMessage diagnose(QualifiedName name, ParameterizedPropertyAccessExpression propertyAccess) {
	// determine containing member declaration and classifier definition
	N4MemberDeclaration containingMemberDeclaration = EcoreUtil2.getContainerOfType(propertyAccess,
			N4MemberDeclaration.class);
	N4ClassifierDefinition classifierDefinition = EcoreUtil2.getContainerOfType(containingMemberDeclaration,
			N4ClassifierDefinition.class);

	// if ancestors present and non-static context (no super in static context)
	if (containingMemberDeclaration != null &&
			!containingMemberDeclaration.isStatic() &&
			classifierDefinition != null) {

		// Get candidate methods
		MemberList<TMember>.MemberIterable<TMethod> methods = containerTypesHelper.fromContext(propertyAccess)
				.membersOfImplementedInterfacesForConsumption((TClassifier) classifierDefinition.getDefinedType())
				.methods();

		boolean hasMethod = methods.stream()
				.filter(m -> !m.isHasNoBody() && !m.isStatic()) // Filter for non-static non-abstract methods
				.anyMatch(m -> m.getName().equals(name.toString()));

		if (hasMethod) {
			return createMessage(IssueCodes.CLF_CANNOT_REFER_TO_DEFAULT_METHOD_WITH_SUPER,
					IssueCodes.getMessageForCLF_CANNOT_REFER_TO_DEFAULT_METHOD_WITH_SUPER());
		}
	}
	return null;
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
protected Resource.Diagnostic createDiagnostic(DiagnosticMessage message) {
	Diagnostic diagnostic = new XtextLinkingDiagnostic(
			node, 
			message.getMessage(),
			message.getIssueCode(), message.getIssueData());
	return diagnostic;
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
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();
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Override
public void acceptError(TransformationErrorCode errorCode, String message, EObject element) {
	setTarget(element, null);
	lastError = errorCode;
	addDiagnostic(new DiagnosticMessage(message, Severity.ERROR, null));	
	lastError = null;
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Override
public DiagnosticMessage getUnresolvedProxyMessage(final ILinkingDiagnosticContext context) {
	DiagnosticMessage diagnosticMessage = new XtextSwitch<DiagnosticMessage>() {
		@Override
		public DiagnosticMessage caseRuleCall(RuleCall ruleCall) {
			return new DiagnosticMessage(context.getLinkText()+" cannot be resolved to a rule", Severity.ERROR,
					UNRESOLVED_RULE, context.getLinkText());
		}

	}.doSwitch(context.getContext());
	return diagnosticMessage != null ? diagnosticMessage : super.getUnresolvedProxyMessage(context);
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
protected void createAndAddDiagnostic(Triple<EObject, EReference, INode> triple) {
	if (isValidationDisabled())
		return;
	DiagnosticMessage message = createDiagnosticMessage(triple);
	if (message != null) {
		List<Diagnostic> list = getDiagnosticList(message);
		Diagnostic diagnostic = createDiagnostic(triple, message);
		if (!list.contains(diagnostic))
			list.add(diagnostic);
	}
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
protected void removeDiagnostic(Triple<EObject, EReference, INode> triple) {
	// return early if there's nothing to remove
	if (getErrors().isEmpty() && getWarnings().isEmpty())
		return;
	DiagnosticMessage message = createDiagnosticMessage(triple);
	List<Diagnostic> list = getDiagnosticList(message);
	if (!list.isEmpty()) {
		Diagnostic diagnostic = createDiagnostic(triple, message);
		list.remove(diagnostic);
	}
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
protected List<Diagnostic> getDiagnosticList(DiagnosticMessage message) throws AssertionError {
	if (message != null) {
		switch (message.getSeverity()) {
			case ERROR:
				return getErrors();
			case WARNING:
				return getWarnings();
			default:
				throw new AssertionError("Unexpected severity: " + message.getSeverity());
		}
	}
	return Collections.emptyList();
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Override
public DiagnosticMessage getUnresolvedProxyMessage(ILinkingDiagnosticContext context) {
	EClass referenceType = context.getReference().getEReferenceType();
	String linkText = "";
	try {
		linkText = context.getLinkText();
	} catch (IllegalNodeException e){
		linkText = e.getNode().getText();
	}
	String msg = "Couldn't resolve reference to " + referenceType.getName() + " '" + linkText + "'.";
	return new DiagnosticMessage(msg, Severity.ERROR, Diagnostic.LINKING_DIAGNOSTIC);
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Override
public DiagnosticMessage getViolatedBoundsConstraintMessage(ILinkingDiagnosticContext context, int size) {
	String message = "Too many matches for reference to '" + context.getLinkText() + "'. " 
			+ "Feature " + context.getReference().getName() + " can only hold " + context.getReference().getUpperBound()
			+ " reference" + (context.getReference().getUpperBound() != 1 ? "s" : "") + " but found " + size + " candidate" +
			(size!=1 ? "s" : "");
	return new DiagnosticMessage(message, Severity.ERROR, Diagnostic.LINKING_DIAGNOSTIC);
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
protected void createDiagnostic(Triple<EObject, EReference, INode> triple) {
	SpecificationElement specificationElement = EcoreUtil2.getContainerOfType(triple.getFirst(),
			SpecificationElement.class);
	DiagnosticMessage message = createDiagnosticMessage(triple);
	Diagnostic diagnostic = new XtextLinkingDiagnostic(triple.getThird(), message.getMessage(),
			message.getIssueCode(), message.getIssueData());
	linkingDiagnostics.put(specificationElement, diagnostic);

}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Override
public DiagnosticMessage getUnresolvedProxyMessage(final ILinkingDiagnosticContext context) {

	EObject object = context.getContext();
	if (object instanceof ConnectionRef) {
		return new DiagnosticMessage("Missing connection declaration", Severity.ERROR,
				IssueCodes.MISSING_CONNECTION_DECL, context.getLinkText());
	}
	return super.getUnresolvedProxyMessage(context);
}
 

import org.eclipse.xtext.diagnostics.DiagnosticMessage; //导入依赖的package包/类
@Override
public DiagnosticMessage getViolatedBoundsConstraintMessage(final ILinkingDiagnosticContext context,
		final int size) {
	final String message = "Too many matches for reference to '" + context.getLinkText() + "'. " + "Feature "
			+ context.getReference().getName() + " can only hold " + context.getReference().getUpperBound()
			+ " reference" + (context.getReference().getUpperBound() != 1 ? "s" : "") + " but found " + size
			+ " candidate" + (size != 1 ? "s" : "");
	return new DiagnosticMessage(message, Severity.ERROR, Diagnostic.LINKING_DIAGNOSTIC);
}