protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
IInvocationExpression newExpression;
using (WriteLockCookie.Create())
{
var factory = CSharpElementFactory.GetInstance(myWarningCreationExpression);
newExpression = (IInvocationExpression)factory.CreateExpression("gameObject.AddComponent<$0>()", myWarningCreationExpression.ExplicitType());
newExpression = ModificationUtil.ReplaceChild(myWarningCreationExpression, newExpression);
}
return(textControl =>
{
var qualifier = newExpression.ExtensionQualifier;
Assertion.AssertNotNull(qualifier, "qualifier != null");
var hotspotExpression = new MacroCallExpressionNew(new SuggestVariableOfTypeMacroDef());
hotspotExpression.AddParameter(new ConstantMacroParameter("UnityEngine.GameObject"));
var field = new TemplateField("gameObject", hotspotExpression, 0);
HotspotInfo[] fieldInfos =
{
new HotspotInfo(field, qualifier.GetDocumentRange())
};
var manager = LiveTemplatesManager.Instance;
var invalidRange = DocumentRange.InvalidRange;
var session = manager.CreateHotspotSessionAtopExistingText(solution, invalidRange,
textControl, LiveTemplatesManager.EscapeAction.LeaveTextAndCaret, fieldInfos);
session.Execute();
});
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
var literalExpression = _highlighting.Expression;
if (!literalExpression.IsValid())
{
return(null);
}
var containingFile = literalExpression.GetContainingFile();
var psiModule = literalExpression.GetPsiModule();
var elementFactory = CSharpElementFactory.GetInstance(literalExpression);
IExpression newExpression = null;
literalExpression.GetPsiServices().Transactions.Execute(GetType().Name, () =>
{
using (solution.GetComponent <IShellLocks>().UsingWriteLock())
newExpression = ModificationUtil.ReplaceChild(
literalExpression.Task, elementFactory.CreateExpression("$0.ConfigureAwait($1)", literalExpression.Task,
elementFactory.CreateExpressionByConstantValue(CSharpConstantValueFactory.CreateBoolValue(_value, psiModule))));
});
if (newExpression != null)
{
var marker = newExpression.GetDocumentRange().CreateRangeMarker(solution.GetComponent <DocumentManager>());
containingFile.OptimizeImportsAndRefs(marker, false, true, NullProgressIndicator.Create());
}
return(null);
}
public void Execute(AccessRights accessRights)
{
var factory = CSharpElementFactory.GetInstance(Context.ParameterDeclaration);
CreateStatement(factory, Context.Parameter.CreateExpression(Context.Parameter) as ICSharpExpression,
Context.SourceFile, accessRights);
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
var psiModule = error.CSharpLiteralExpression.GetPsiModule();
var factory = CSharpElementFactory.GetInstance(error.CSharpLiteralExpression);
var taskType = TypeFactory.CreateTypeByCLRName("System.Threading.Tasks.Task", psiModule);
if (error.ReturnType.IsTask())
{
var completedTask = factory.CreateReferenceExpression("$0.CompletedTask", taskType);
error.CSharpLiteralExpression.ReplaceBy(completedTask);
}
else if (error.ReturnType.IsGenericTask())
{
var declaredReturnType = error.ReturnType as IDeclaredType;
if (declaredReturnType == null)
{
return(null);
}
var substitution = declaredReturnType.GetSubstitution();
var genericParameter = substitution.Apply(substitution.Domain[0]);
var wrappedNull = factory.CreateExpression(
genericParameter.IsStructType() ? "$0.FromResult(default($1))" : "$0.FromResult<$1>(null)",
taskType,
genericParameter);
error.CSharpLiteralExpression.ReplaceBy(wrappedNull);
}
return(null);
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
using (WriteLockCookie.Create())
{
var qualifierOperand = (myRewriteLeftOperand ? myExpression.LeftOperand : myExpression.RightOperand) as IReferenceExpression;
var qualifierExpression = qualifierOperand?.QualifierExpression;
var otherOperand = myRewriteLeftOperand ? myExpression.RightOperand : myExpression.LeftOperand;
var factory = CSharpElementFactory.GetInstance(myExpression);
ICSharpExpression newExpression;
if (qualifierExpression != null)
{
newExpression = factory.CreateExpression("$0$1.CompareTag($2)",
myExpression.EqualityType == EqualityExpressionType.EQEQ ? string.Empty : "!",
qualifierExpression, otherOperand);
}
else
{
newExpression = factory.CreateExpression("$0CompareTag($1)",
myExpression.EqualityType == EqualityExpressionType.EQEQ ? string.Empty : "!",
otherOperand);
}
ModificationUtil.ReplaceChild(myExpression, newExpression);
}
return(null);
}
private IModifiersList GetModifierList(ITreeNode declaration)
{
return
(((IMethodDeclaration)
CSharpElementFactory.GetInstance(declaration)
.CreateTypeMemberDeclaration(this.Modifier + " void Foo(){}")).ModifiersList);
}
/// <summary>
/// The execute inner.
/// </summary>
/// <param name="solution">
/// The solution.
/// </param>
/// <param name="textControl">
/// The text control.
/// </param>
public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
{
ICSharpModifiersOwnerDeclaration declaration = Utils.GetTypeClosestToTextControl <ICSharpModifiersOwnerDeclaration>(solution, textControl);
if (declaration != null)
{
string rulesNamespace = this.Rule.Namespace;
string ruleText = string.Format("{0}:{1}", this.Rule.CheckId, this.Rule.Name);
IContextBoundSettingsStore settingsStore = PsiSourceFileExtensions.GetSettingsStore(null, solution);
string justificationText = settingsStore.GetValue((StyleCopOptionsSettingsKey key) => key.SuppressStyleCopAttributeJustificationText);
IAttributesOwnerDeclaration attributesOwnerDeclaration = declaration as IAttributesOwnerDeclaration;
CSharpElementFactory factory = CSharpElementFactory.GetInstance(declaration.GetPsiModule());
ITypeElement typeElement = Utils.GetTypeElement(declaration, "System.Diagnostics.CodeAnalysis.SuppressMessageAttribute");
IAttribute attribute = factory.CreateAttribute(typeElement);
ICSharpArgument newArg1 = attribute.AddArgumentAfter(Utils.CreateConstructorArgumentValueExpression(declaration.GetPsiModule(), rulesNamespace), null);
ICSharpArgument newArg2 = attribute.AddArgumentAfter(Utils.CreateConstructorArgumentValueExpression(declaration.GetPsiModule(), ruleText), newArg1);
attribute.AddArgumentAfter(Utils.CreateArgumentValueExpression(declaration.GetPsiModule(), "Justification = \"" + justificationText + "\""), newArg2);
attributesOwnerDeclaration.AddAttributeAfter(attribute, null);
}
}
private static ILookupItem CreateMethodItem(CSharpCodeCompletionContext context, UnityEventFunction eventFunction,
IClassLikeDeclaration declaration)
{
if (CSharpLanguage.Instance == null)
{
return(null);
}
var method = eventFunction.CreateDeclaration(CSharpElementFactory.GetInstance(declaration), declaration);
if (method.DeclaredElement == null)
{
return(null);
}
var instance = new DeclaredElementInstance(method.DeclaredElement);
var declaredElementInfo = new DeclaredElementInfo(method.DeclaredName, instance, CSharpLanguage.Instance,
context.BasicContext.LookupItemsOwner, context, context.BasicContext);
return(LookupItemFactory.CreateLookupItem(declaredElementInfo).
WithPresentation(
_ => new GenerateMemberPresentation(declaredElementInfo, PresenterStyles.DefaultPresenterStyle)).
WithBehavior(_ =>
{
var behavior = new UnityEventFunctionBehavior(declaredElementInfo, eventFunction);
behavior.InitializeRanges(context.CompletionRanges, context.BasicContext);
return behavior;
}).
WithMatcher(_ => new DeclaredElementMatcher(declaredElementInfo, context.BasicContext.IdentifierMatchingStyle)));
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator _)
{
var methodDeclaration = Highlighting.MethodDeclaration;
var elementFactory = CSharpElementFactory.GetInstance(methodDeclaration);
var parameterDeclaration = methodDeclaration.AddParameterDeclarationBefore(
elementFactory.CreateParameterDeclaration(
ParameterKind.VALUE,
isParametric: false,
isVarArg: false,
type: Highlighting.ArgumentExpression.Type(),
name: "newParameter",
defaultValue: null), anchor: null);
return(textControl =>
{
var endSelectionRange = DocumentRange.InvalidRange;
var hotspotNode = parameterDeclaration.NameIdentifier;
var hotspotSession = textControl.CreateHotspotSessionAtopExistingText(solution, endSelectionRange, hotspotNode);
hotspotSession.Execute();
});
}
public void Execute(ISolution solution, ITextControl textControl)
{
if (!_literalExpression.IsValid())
{
return;
}
var containingFile = _literalExpression.GetContainingFile();
var psiModule = _literalExpression.GetPsiModule();
var elementFactory = CSharpElementFactory.GetInstance(psiModule);
IExpression newExpression = null;
_literalExpression.GetPsiServices().Transactions.Execute(GetType().Name, () =>
{
using (solution.GetComponent <IShellLocks>().UsingWriteLock())
newExpression = ModificationUtil.ReplaceChild(
_literalExpression.Task, elementFactory.CreateExpression("$0.ConfigureAwait($1)", _literalExpression.Task,
elementFactory.CreateExpressionByConstantValue(CSharpConstantValueFactory.CreateBoolValue(_value, psiModule))));
});
if (newExpression != null)
{
IRangeMarker marker = newExpression.GetDocumentRange().CreateRangeMarker(solution.GetComponent <DocumentManager>());
containingFile.OptimizeImportsAndRefs(marker, false, true, NullProgressIndicator.Instance);
}
}
/// <summary>
/// Process local variable declaration.
/// </summary>
/// <param name="localVariableDeclaration">
/// The local variable declaration.
/// </param>
private static void ProcessLocalVariableDeclaration(ILocalVariableDeclaration localVariableDeclaration)
{
IMultipleLocalVariableDeclaration multipleDeclaration = MultipleLocalVariableDeclarationNavigator.GetByDeclarator(localVariableDeclaration);
if (multipleDeclaration.Declarators.Count > 1)
{
IType newType = CSharpTypeFactory.CreateType(multipleDeclaration.TypeUsage);
using (WriteLockCookie.Create(true))
{
multipleDeclaration.SetTypeUsage(CSharpElementFactory.GetInstance(localVariableDeclaration.GetPsiModule()).CreateTypeUsageNode(newType));
}
}
else
{
ILocalVariable variable = localVariableDeclaration.DeclaredElement;
if (variable != null)
{
if (!multipleDeclaration.IsVar)
{
using (WriteLockCookie.Create(true))
{
localVariableDeclaration.SetType(variable.Type);
}
}
}
}
}
public void Process(IPsiSourceFile sourceFile, IRangeMarker rangeMarker, CodeCleanupProfile profile, IProgressIndicator progressIndicator)
{
var file = sourceFile.GetNonInjectedPsiFile <CSharpLanguage>();
if (file == null)
{
return;
}
if (!profile.GetSetting(DescriptorInstance))
{
return;
}
CSharpElementFactory elementFactory = CSharpElementFactory.GetInstance(sourceFile.PsiModule);
file.GetPsiServices().PsiManager.DoTransaction(
() =>
{
using (_shellLocks.UsingWriteLock())
file.ProcessChildren <IExpression>(
expression =>
{
ConstantValue value = expression.ConstantValue;
if (value.IsInteger() && Convert.ToInt32(value.Value) == int.MaxValue)
{
ModificationUtil.ReplaceChild(expression, elementFactory.CreateExpression("int.MaxValue"));
}
}
);
},
"Code cleanup");
}
private bool TryConvertSyncToAwaitWaiting([NotNull] IInvocationExpression invocationExpression)
{
var reference = invocationExpression.Parent as IReferenceExpression;
var factory = CSharpElementFactory.GetInstance(invocationExpression);
//TODO: AwaitResult our custom method extension, it must be moved to settings
if (reference?.NameIdentifier?.Name == "AwaitResult" || reference?.NameIdentifier?.Name == "Wait")
{
var call = factory.CreateExpression("await $0($1).ConfigureAwait(false)", invocationExpression.ConditionalQualifier,
invocationExpression.ArgumentList);
var parentInvocation = reference.Parent as IInvocationExpression;
if (parentInvocation == null)
{
return(false);
}
parentInvocation.ReplaceBy(call);
return(true);
}
if (reference?.NameIdentifier?.Name == "Result")
{
var call = factory.CreateExpression("await $0($1).ConfigureAwait(false)", invocationExpression.ConditionalQualifier,
invocationExpression.ArgumentList);
reference.ReplaceBy(call);
return(true);
}
return(false);
}
private static IBlock CreateMethodBody(ICSharpDeclaration declaration, MethodImplementationKind implementationKind)
{
var factory = CSharpElementFactory.GetInstance(declaration);
switch (implementationKind)
{
case MethodImplementationKind.ThrowNotImplemented:
{
var predefinedType = declaration.GetPredefinedType();
return(factory.CreateBlock("{throw new $0();}", predefinedType.NotImplementedException));
}
case MethodImplementationKind.ReturnDefaultValue:
{
return(CSharpReturnStatementMemberBodyProvider.CreateBody(declaration));
}
case MethodImplementationKind.NotCompiledCode:
{
if (declaration.DeclaredElement is IMethod method && !method.ReturnType.IsVoid())
{
return(factory.CreateBlock("{ return TODO_IMPLEMENT_ME; }"));
}
return(factory.CreateBlock("{ TODO_IMPLEMENT_ME(); }"));
}
default:
{
throw new ArgumentOutOfRangeException(nameof(implementationKind));
}
}
}
public TypeHandlingContext(CSharpGeneratorContext generatorContext)
{
GeneratorContext = generatorContext;
ElementFactory = CSharpElementFactory.GetInstance(generatorContext.Root.GetPsiModule());
Builder = new StringBuilder();
Args = new List <Object>();
Variables = new VariablesTracker();
}
protected override ICSharpExpression CreateReplacementExpression(ICSharpExpression expression, IDeclaredElement declaredElement)
{
CSharpElementFactory factory = CSharpElementFactory.GetInstance(expression);
return(factory.CreateReferenceExpression("$0.$1",
((IReferenceExpression)expression).QualifierExpression,
declaredElement.ShortName));
}
/// <summary>
/// Swap base to this unless local implementation.
/// </summary>
/// <param name="invocationExpression">
/// The invocation expression.
/// </param>
public static void SwapBaseToThisUnlessLocalImplementation(IInvocationExpression invocationExpression)
{
bool isOverride = false;
bool isNew = false;
IPrimaryExpression invokedExpression = invocationExpression.InvokedExpression;
if (invokedExpression != null)
{
IReferenceExpression referenceExpressionNode = invokedExpression as IReferenceExpression;
if (referenceExpressionNode != null)
{
IReferenceExpression referenceExpression = invokedExpression as IReferenceExpression;
if (referenceExpression != null)
{
ICSharpExpression qualifierExpression = referenceExpression.QualifierExpression;
if (qualifierExpression is IBaseExpression)
{
string methodName = referenceExpressionNode.NameIdentifier.Name;
ICSharpTypeDeclaration typeDeclaration = invocationExpression.GetContainingNode <ICSharpTypeDeclaration>(true);
if (typeDeclaration != null)
{
foreach (ICSharpTypeMemberDeclaration memberDeclaration in typeDeclaration.MemberDeclarations)
{
if (memberDeclaration.DeclaredName == methodName)
{
IMethodDeclaration methodDeclaration = memberDeclaration as IMethodDeclaration;
if (methodDeclaration != null)
{
isOverride = methodDeclaration.IsOverride;
isNew = methodDeclaration.IsNew();
break;
}
}
}
if (isOverride || isNew)
{
return;
}
using (WriteLockCookie.Create(true))
{
// swap the base to this
ICSharpExpression expression = CSharpElementFactory.GetInstance(invocationExpression.GetPsiModule()).CreateExpression("this");
referenceExpression.SetQualifierExpression(expression);
}
}
}
}
}
}
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
if (myPropertyDeclaration == null)
{
return(null);
}
return(AutoPropertyToSerializedBackingFieldAction.Execute(myPropertyDeclaration, solution,
CSharpElementFactory.GetInstance(myPropertyDeclaration)));
}
protected ContextActionExecutorBase(ICSharpStatement statement)
{
Contract.Requires(statement != null);
_psiModule = statement.GetPsiModule();
_psiServices = statement.GetPsiServices();
_factory = CSharpElementFactory.GetInstance(statement);
_currentFile = (ICSharpFile)statement.GetContainingFile();
}
public InitializeComponentBulbActionBase(string name, ITypeElement typeElement,
IClassDeclaration classDeclaration, string methodName)
{
myName = name;
myTypeElement = typeElement;
myClassDeclaration = classDeclaration;
myMethodName = methodName;
myFactory = CSharpElementFactory.GetInstance(classDeclaration);
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
var awaitExpression = configureAwaitHighlighting.AwaitExpression;
var factory = CSharpElementFactory.GetInstance(awaitExpression);
var taskWithConfiguring = factory.CreateExpression($"$0.ConfigureAwait({GetConfigureAwaitValueText()})", awaitExpression.Task);
awaitExpression.Task.ReplaceBy(taskWithConfiguring);
return(null);
}
public static void SetDocComment(IDocCommentBlockOwnerNode docCommentBlockOwnerNode, string text, ISolution solution)
{
text = String.Format("///{0}\r\nclass Tmp {{}}", text.Replace("\n", "\n///"));
ICSharpTypeMemberDeclaration declaration =
CSharpElementFactory.GetInstance(docCommentBlockOwnerNode.GetPsiModule()).CreateTypeMemberDeclaration(text, new object[0]);
docCommentBlockOwnerNode.SetDocCommentBlockNode(
((IDocCommentBlockOwnerNode)declaration).GetDocCommentBlockNode());
}
private IAttribute createAttributeDeclaration(ITypeElement attributeType, string fixedParamValue, string namedParamName, string namedParamValue, IPsiModule psiModule, IModuleReferenceResolveContext resolveContext, IAttribute originalAttribute)
{
var fixedArguments = createFixedArguments(fixedParamValue, psiModule, resolveContext);
var namedArguments = createNamedArguments(namedParamName, namedParamValue, psiModule, resolveContext, originalAttribute);
var elementFactory = CSharpElementFactory.GetInstance(psiModule);
var attributeDeclaration = elementFactory.CreateAttribute(attributeType, fixedArguments, namedArguments);
return(attributeDeclaration);
}
public override void ProcessParameterReference(IReference reference)
{
var referenceExpression = reference as IReferenceExpression;
if (referenceExpression != null)
{
CSharpElementFactory factory = CSharpElementFactory.GetInstance(referenceExpression.GetPsiModule());
referenceExpression.ReplaceBy(factory.CreateExpression("typeof($0)", Workflow.TypeParameterName));
}
}
public void Accept(
ITextControl textControl, TextRange nameRange, LookupItemInsertType lookupItemInsertType,
Suffix suffix, ISolution solution, bool keepCaretStill)
{
textControl.Document.ReplaceText(nameRange, CASE_COMPLETION_NAME + "()");
var psiServices = solution.GetPsiServices();
psiServices.Files.CommitAllDocuments();
var enumMember = Info.PreferredDeclaredElement;
if (enumMember == null)
{
return;
}
var invocationExpression = FindFakeInvocation(textControl, solution, nameRange.EndOffset);
if (invocationExpression == null)
{
return;
}
var factory = CSharpElementFactory.GetInstance(invocationExpression);
var template = (Info.IsFlagsEnum && !Info.IsZeroCase)
? (Info.IsMultiBitFlagCase ? "($0 & $1) != $1" : "($0 & $1) != 0")
: "$0 == $1";
var referenceExpression = (IReferenceExpression)invocationExpression.InvokedExpression;
var qualifierExpression = referenceExpression.QualifierExpression;
var enumMemberCheck = factory.CreateExpression(template, qualifierExpression, enumMember);
var caretPointer = psiServices.DoTransaction(
commandName: typeof(EnumCaseCheckBehavior).FullName,
func: () =>
{
using (WriteLockCookie.Create())
{
var memberCheck = invocationExpression.ReplaceBy(enumMemberCheck);
return(memberCheck.CreateTreeElementPointer());
}
});
if (caretPointer != null)
{
var checkExpression = caretPointer.GetTreeNode();
if (checkExpression != null)
{
var offset = checkExpression.GetDocumentRange().TextRange.EndOffset;
textControl.Caret.MoveTo(offset, CaretVisualPlacement.DontScrollIfVisible);
}
}
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
using (WriteLockCookie.Create())
{
var factory = CSharpElementFactory.GetInstance(_stringLiteral.Expression, false);
var expression = factory.CreateExpression(
$"\"{_stringLiteral.Expression.GetUnquotedText().Insert(_namedProperty.StartIndex + 1, "@")}\"");
ModificationUtil.ReplaceChild(_stringLiteral.Expression, expression);
}
return(null);
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
var factory = CSharpElementFactory.GetInstance(_theclass.GetPsiModule());
if (factory == null)
{
return(null);
}
AddProxyClass(_theclass, factory);
return(null);
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
using (WriteLockCookie.Create())
{
var leftOperand = myExpression.LeftOperand;
var rightOperand = myExpression.RightOperand;
var factory = CSharpElementFactory.GetInstance(myExpression);
var newExpression = factory.CreateExpression("$0?$0:$1", leftOperand, rightOperand);
ModificationUtil.ReplaceChild(myExpression, newExpression);
}
return(null);
}
/// <summary>
/// Swap object creation to built in type.
/// </summary>
/// <param name="objectCreationExpressionNode">
/// The object creation expression node.
/// </param>
private static void SwapObjectCreationToBuiltInType(IObjectCreationExpression objectCreationExpressionNode)
{
IPsiModule project = objectCreationExpressionNode.GetPsiModule();
using (WriteLockCookie.Create(true))
{
IObjectCreationExpression tmpExpression =
(IObjectCreationExpression)
CSharpElementFactory.GetInstance(project).CreateExpression("new $0?()", new object[] { objectCreationExpressionNode.Type() });
objectCreationExpressionNode.SetCreatedTypeUsage(tmpExpression.CreatedTypeUsage);
}
}
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));
}
