public void MakeCallShared(IReference reference)
{
var referenceExpression1 = reference.GetTreeNode() as IReferenceExpression;
if (referenceExpression1 == null || !reference.Resolve().Result.IsExtensionMethod())
{
return;
}
var byExpression = IndexExpressionNavigator.GetByExpression(referenceExpression1);
if (byExpression == null)
{
return;
}
var substitution = reference.Resolve().Result.Substitution;
var referenceExpression2 = byExpression.Expression as IReferenceExpression;
if (referenceExpression2 == null)
{
return;
}
var instance = VBElementFactory.GetInstance(referenceExpression1.GetPsiModule());
var vbExpression = referenceExpression2.QualifierExpression ?? instance.CreateExpression("me", new object[0]);
byExpression.AddArgumentAfter(instance.CreateArgument(vbExpression), null);
//byExpression.SetExpression(instance.CreateReferenceExpression(this.Executer.Method.ShortName, new object[0]));
//((IReferenceExpression)byExpression.Expression).Reference.BindTo((IDeclaredElement)this.Executer.Method);
//if (((IReferenceExpression)byExpression.Expression).Reference.BindTo((IDeclaredElement)this.Workflow.Method, substitution).CheckResolveResult() == ResolveErrorType.OK) return;
//this.Driver.AddConflict((IConflict)ReferenceConflict.CreateError(reference, "{0} can not be transformed correctly"));
}
private static bool IsStringConcatOperatorReference([CanBeNull] IReference reference)
{
if (reference == null)
{
return(false);
}
var @operator = reference.Resolve().DeclaredElement as IOperator;
if (@operator == null || [email protected])
{
return(false);
}
var parameters = @operator.Parameters;
if (parameters.Count != 2)
{
return(false);
}
IType lhsType = parameters[0].Type, rhsType = parameters[1].Type;
if (lhsType.IsString())
{
return(rhsType.IsString() || rhsType.IsObject());
}
if (rhsType.IsString())
{
return(lhsType.IsString() || lhsType.IsObject());
}
return(false);
}
public static T GetResolved <T> (this IReference reference)
where T : IDeclaredElement
{
var resolveResult = reference.Resolve();
return(resolveResult.DeclaredElement is T ? (T)resolveResult.DeclaredElement : default(T));
}
public ResolveResultWithInfo Resolve()
{
if (!myInitReference)
{
myReference = new PsiVariableReference(this);
myInitReference = true;
}
return(myReference.Resolve());
}
public static ResolveResultWithInfo GetResolveResult(this IReference reference)
{
if (reference.CurrentResolveResult != null)
{
return(reference.CurrentResolveResult);
}
return(reference.Resolve());
}
private static DeclaredElementInstance TryResolveReference([CanBeNull] IReference reference)
{
IResolveResult resolveResult = reference?.Resolve().Result;
if (resolveResult?.DeclaredElement != null)
{
return(new DeclaredElementInstance(resolveResult.DeclaredElement, resolveResult.Substitution));
}
return(null);
}
public override MethodInvocation ProcessUsage(IReference reference)
{
var referenceExpression = reference.GetTreeNode() as IReferenceExpression;
if (referenceExpression == null)
{
Driver.AddConflict(ReferenceConflict.CreateError(reference, "{0} can not be updated correctly.", "Usage"));
return(null);
}
bool isExtensionMethod = referenceExpression.IsExtensionMethod();
IInvocationExpression invocation = InvocationExpressionNavigator.GetByInvokedExpression(referenceExpression);
if (invocation == null)
{
Driver.AddConflict(ReferenceConflict.CreateError(reference, "{0} can not be updated correctly.", "Usage"));
return(null);
}
ITreeNode element = GetArgument(invocation, isExtensionMethod);
var argument = element as ICSharpArgument;
IType type = argument != null?GetTypeOfValue(argument.Value) : GetTypeOfValue(element);
if (type == null || !type.CanUseExplicitly(invocation))
{
Driver.AddConflict(ReferenceConflict.CreateError(
reference, "Argument of {0} is not valid 'typeof' expression.", "usage"));
return(null);
}
// we can rely on resolve result since method declaration is not yet changed.
ResolveResultWithInfo resolveResult = reference.Resolve();
ISubstitution substitution = resolveResult.Result.Substitution;
var method = resolveResult.DeclaredElement as IMethod;
if (method == null)
{
return(null);
}
if (argument != null)
{
invocation.RemoveArgument(argument);
return(new MethodInvocation(reference, type, method, substitution));
}
CSharpElementFactory factory = CSharpElementFactory.GetInstance(invocation.GetPsiModule());
IReferenceExpression newInvokedExpression =
invocation.InvokedExpression.ReplaceBy(factory.CreateReferenceExpression("$0", Executer.Method));
return(new MethodInvocation(newInvokedExpression.Reference, type, method, substitution));
}
public void MakeCallShared(IReference reference)
{
var referenceExpression1 = reference.GetTreeNode() as IReferenceExpression;
if (referenceExpression1 == null || !reference.Resolve().Result.IsExtensionMethod()) return;
var byExpression = IndexExpressionNavigator.GetByExpression(referenceExpression1);
if (byExpression == null) return;
var substitution = reference.Resolve().Result.Substitution;
var referenceExpression2 = byExpression.Expression as IReferenceExpression;
if (referenceExpression2 == null) return;
var instance = VBElementFactory.GetInstance(referenceExpression1.GetPsiModule());
var vbExpression = referenceExpression2.QualifierExpression ?? instance.CreateExpression("me", new object[0]);
byExpression.AddArgumentAfter(instance.CreateArgument(vbExpression), null);
//byExpression.SetExpression(instance.CreateReferenceExpression(this.Executer.Method.ShortName, new object[0]));
//((IReferenceExpression)byExpression.Expression).Reference.BindTo((IDeclaredElement)this.Executer.Method);
//if (((IReferenceExpression)byExpression.Expression).Reference.BindTo((IDeclaredElement)this.Workflow.Method, substitution).CheckResolveResult() == ResolveErrorType.OK) return;
//this.Driver.AddConflict((IConflict)ReferenceConflict.CreateError(reference, "{0} can not be transformed correctly"));
}
private static IDeclaredType GetCSharpPropertyScalarType(IReference reference)
{
var info = reference.Resolve();
if (info.DeclaredElement.IsCSharpProperty() == false)
{
return(null);
}
var property = info.DeclaredElement as IProperty;
return(property?.ReturnType.GetScalarType());
}
public override MethodInvocation ProcessUsage(IReference reference)
{
var referenceExpression = reference.GetTreeNode() as IReferenceExpression;
if (referenceExpression == null)
{
Driver.AddConflict(ReferenceConflict.CreateError(reference, "{0} can not be updated correctly.", "Usage"));
return null;
}
bool isExtensionMethod = referenceExpression.IsExtensionMethod();
IInvocationExpression invocation = InvocationExpressionNavigator.GetByInvokedExpression(referenceExpression);
if (invocation == null)
{
Driver.AddConflict(ReferenceConflict.CreateError(reference, "{0} can not be updated correctly.", "Usage"));
return null;
}
ITreeNode element = GetArgument(invocation, isExtensionMethod);
var argument = element as ICSharpArgument;
IType type = argument != null ? GetTypeOfValue(argument.Value) : GetTypeOfValue(element);
if (type == null || !type.CanUseExplicitly(invocation))
{
Driver.AddConflict(ReferenceConflict.CreateError(
reference, "Arguemnt of {0} is not valid 'typeof' expression.", "usage"));
return null;
}
// we can rely on resolve result since method declaration is not yet changed.
ResolveResultWithInfo resolveResult = reference.Resolve();
ISubstitution substitution = resolveResult.Result.Substitution;
var method = resolveResult.DeclaredElement as IMethod;
if (method == null)
return null;
if (argument != null)
{
invocation.RemoveArgument(argument);
return new MethodInvocation(reference, type, method, substitution);
}
CSharpElementFactory factory = CSharpElementFactory.GetInstance(invocation.GetPsiModule());
IReferenceExpression newInvokedExpression =
invocation.InvokedExpression.ReplaceBy(factory.CreateReferenceExpression("$0", Executer.Method));
return new MethodInvocation(newInvokedExpression.Reference, type, method, substitution);
}
public static void AppendCandidates([NotNull] this CSharpColorizer colorizer, [CanBeNull] IReference reference)
{
if (reference == null)
{
return;
}
IResolveResult resolveResult = reference.Resolve().Result;
IList <IDeclaredElement> candidates = resolveResult.Candidates;
IList <ISubstitution> substitutions = resolveResult.CandidateSubstitutions;
for (int i = 0; i < candidates.Count; ++i)
{
colorizer.AppendPlainText(Environment.NewLine);
colorizer.AppendPlainText(" ");
colorizer.AppendDeclaredElement(candidates[i].EliminateDelegateInvokeMethod(), substitutions[i], PresenterOptions.FullWithoutParameterNames, reference.GetTreeNode());
}
}
protected virtual void HighlightReference(IElement element, IReference reference)
{
if (reference.ReferenceType == ReferenceType.TEXT
|| reference.ReferenceType == ReferenceType.REFERENCE_NAME
|| reference.ReferenceType == ReferenceType.LABEL)
{
ResolveResult resolveResult = reference.Resolve();
// TODO resolveResult.DeclaredElement == null property@name !!!
if (resolveResult.DeclaredElement != null)
{
DocumentRange range = reference.GetDocumentRange();
DocumentRange footerRange = XMLPSIUtils.GetFooterTagRange(element, range);
Highlight(range, resolveResult.DeclaredElement);
if (footerRange != DocumentRange.InvalidRange)
Highlight(footerRange, resolveResult.DeclaredElement);
}
}
}
private static IType TryGetClosedReturnTypeFromReference(IReference reference)
{
var resolveResultWithInfo = GetResolveResult(reference);
if (reference.CurrentResolveResult == null)
{
reference.Resolve();
}
var declaredElement = resolveResultWithInfo.DeclaredElement;
var parametersOwner = declaredElement as IParametersOwner;
if (parametersOwner != null)
{
var returnType = parametersOwner.ReturnType;
return(returnType.IsOpenType ? GetClosedType(resolveResultWithInfo, returnType) : returnType);
}
return(null);
}
public IHighlighting Run(IReference reference)
{
var resolveResult = reference.Resolve();
if (resolveResult.Result.Candidates.Count > 1)
{
var candidates = resolveResult.Result.Candidates;
var result = new List <string>();
foreach (var candidate in candidates)
{
result.Add(Environment.NewLine + " " + DeclaredElementPresenter.Format(ShaderLabLanguage.Instance,
ShaderLabDeclaredElementPresenterStyles.CANDIDATE_PRESENTER, candidate));
}
result.Sort();
var message = result.AggregateString("");
var range = reference.GetDocumentRange();
return(new MultipleResolveCandidatesError(range, message, reference));
}
return(null);
}
public static void AppendCandidates([NotNull] this CSharpColorizer colorizer, [CanBeNull] IReference reference)
{
if (reference == null)
{
return;
}
IResolveResult resolveResult = reference.Resolve().Result;
var liftedResolveResult = resolveResult as LiftedResolveResult;
// ReSharper disable once CoVariantArrayConversion
IList <IDeclaredElement> candidates = liftedResolveResult != null ? liftedResolveResult.LiftedCandidates : resolveResult.Candidates;
IList <ISubstitution> substitutions = resolveResult.CandidateSubstitutions;
for (int i = 0; i < candidates.Count; ++i)
{
colorizer.AppendPlainText(Environment.NewLine);
colorizer.AppendPlainText(" ");
colorizer.AppendDeclaredElement(candidates[i].EliminateDelegateInvokeMethod(), substitutions[i], PresenterOptions.FullWithoutParameterNames);
}
}
protected virtual IResolveResult Resolve(IReference reference)
{
return(reference.Resolve().Result);
}
public static ResolveResultWithInfo GetResolveResult(this IReference reference)
{
return(reference.CurrentResolveResult ?? reference.Resolve());
}
private static string GetMethodName([CanBeNull] IReference reference)
{
var info = reference?.Resolve();
return(info?.ResolveErrorType == ResolveErrorType.OK ? info.DeclaredElement?.ShortName : null);
}
public static bool IsStringConcatOperatorReference([CanBeNull] this IReference reference)
{
if (reference?.Resolve() is (ISignOperator {
IsPredefined : true, Parameters : { Count : 2 } parameters
}, _))
private static DeclaredElementInstance?TryResolveReference(IReference?reference)
=> reference?.Resolve().Result is
{
