private void CheckForResolveProblems(IHighlightingConsumer consumer, IReference reference)
{
var error = reference.CheckResolveResult();
if (error == null)
{
throw new InvalidOperationException("ResolveErrorType is null for reference " +
reference.GetType().FullName);
}
if (error == ResolveErrorType.OK)
{
return;
}
if (myResolveHighlighterRegistrar.ContainsHandler(ShaderLabLanguage.Instance, error))
{
var highlighting = myResolveHighlighterRegistrar.GetResolveHighlighting(reference, error);
if (highlighting != null)
{
consumer.AddHighlighting(highlighting);
}
}
else
{
consumer.AddHighlighting(new NotResolvedError(reference));
}
}
private bool IsUnresolvedOrWrongNameCase()
{
var type = _myReference.CheckResolveResult();
return(type == ResolveErrorType.NOT_RESOLVED ||
type == ResolveErrorType.WRONG_NAME_CASE);
}
private void CheckForResolveProblems(IHighlightingConsumer consumer, IReference reference)
{
var resolveErrorType = reference.CheckResolveResult();
if (resolveErrorType == null)
{
throw new InvalidOperationException("ResolveErrorType is null for reference " + reference.GetType().FullName);
}
if (resolveErrorType.IsAcceptable)
{
return;
}
// ReSharper disable once AssignNullToNotNullAttribute
if (myResolveHighlighterRegistrar.ContainsHandler(YamlLanguage.Instance, resolveErrorType))
{
var highlighting = myResolveHighlighterRegistrar.GetResolveHighlighting(reference, resolveErrorType);
if (highlighting != null)
{
consumer.AddHighlighting(highlighting);
}
}
else
{
consumer.AddHighlighting(new NotResolvedError(reference));
}
}
protected virtual void CheckForResolveProblems(IReference reference)
{
IQualifiableReference qualifiableReference = reference as IQualifiableReference;
if (((qualifiableReference == null) || !qualifiableReference.IsQualified) || qualifiableReference.GetQualifier().Resolved)
{
ResolveErrorType result = reference.CheckResolveResult();
if (result != ResolveErrorType.OK)
{
NotResolvedError notResolvedError = new NotResolvedError(reference);
highlightings.Add(new HighlightingInfo(notResolvedError.Range, notResolvedError));
}
}
}
// We only get called for our known resolve errors
public IHighlighting Run(IReference reference)
{
var errorType = reference.CheckResolveResult();
if (errorType == UnityResolveErrorType.EXPECTED_COMPONENT)
{
return(new ExpectedComponentWarning(reference, KnownTypes.Component.FullName));
}
if (errorType == UnityResolveErrorType.EXPECTED_MONO_BEHAVIOUR)
{
return(new ExpectedComponentWarning(reference, KnownTypes.MonoBehaviour.FullName));
}
if (errorType == UnityResolveErrorType.EXPECTED_SCRIPTABLE_OBJECT)
{
return(new ExpectedScriptableObjectWarning(reference));
}
return(null);
}
private void CheckForResolveProblems(IHighlightingConsumer consumer, IReference reference)
{
var error = reference.CheckResolveResult();
if (error == null)
{
throw new InvalidOperationException("ResolveErrorType is null for reference " +
reference.GetType().FullName);
}
if (error == ResolveErrorType.OK)
{
return;
}
// ReSharper disable once AssignNullToNotNullAttribute
if (myResolveHighlighterRegistrar.ContainsHandler(ShaderLabLanguage.Instance, error))
{
var highlighting = myResolveHighlighterRegistrar.GetResolveHighlighting(reference, error);
if (highlighting != null)
{
consumer.AddHighlighting(highlighting);
}
}
else
{
// The default is unresolved. But we can't use something like NotResolvedError because:
// a) Using an undeclared property in ShaderLab isn't a compile time error. An undeclared
// property just uses the default value
// b) Properties can be set from code, without having to be declared first
// c) There is at least one hidden property `unity_GUIZTestMode`
//
// So, this could be:
// a) a typo
// b) an external reference
//
// How do we tell the difference, and how do we show the difference?
// For now, just don't give an error
consumer.AddHighlighting(new NotResolvedPropertyWarning(reference));
}
}
