public IPostfixLookupItem CreateItem(PostfixTemplateContext context)
{
var typeExpression = context.TypeExpression;
if (typeExpression == null)
{
return(CreateExpressionItem(context));
}
var typeElement = typeExpression.ReferencedElement as ITypeElement;
if (typeElement == null)
{
return(null);
}
if (context.IsAutoCompletion)
{
if (!TypeUtils.IsUsefulToCreateWithNew(typeElement))
{
return(null);
}
}
var canInstantiate = TypeUtils.CanInstantiateType(typeElement, typeExpression.Expression);
if (canInstantiate != CanInstantiate.No)
{
var hasParameters = (canInstantiate & CanInstantiate.ConstructorWithParameters) != 0;
return(new NewTypeItem(typeExpression, hasParameters));
}
return(null);
}
protected override void AfterComplete(ITextControl textControl, IThrowStatement statement)
{
if (statement.Semicolon != null)
{
FormatStatementOnSemicolon(statement);
}
var settingsStore = statement.GetSettingsStore();
var expression = (IObjectCreationExpression)statement.Exception;
var parenthesesType = settingsStore.GetValue(CodeCompletionSettingsAccessor.ParenthesesInsertType);
if (parenthesesType == ParenthesesInsertType.None)
{
var endOffset = expression.GetDocumentRange().TextRange.EndOffset;
textControl.Caret.MoveTo(endOffset, CaretVisualPlacement.DontScrollIfVisible);
}
else
{
var canInstantiate = TypeUtils.CanInstantiateType(statement.Exception.Type(), statement);
var hasRequiredArguments = (canInstantiate & CanInstantiate.ConstructorWithParameters) != 0;
var caretNode = hasRequiredArguments ? expression.LPar : (statement.Semicolon ?? (ITreeNode)expression);
var endOffset = caretNode.GetDocumentRange().TextRange.EndOffset;
textControl.Caret.MoveTo(endOffset, CaretVisualPlacement.DontScrollIfVisible);
if (hasRequiredArguments && settingsStore.GetValue(PostfixTemplatesSettingsAccessor.InvokeParameterInfo))
{
var lookupItemsOwner = Info.ExecutionContext.LookupItemsOwner;
LookupUtil.ShowParameterInfo(statement.GetSolution(), textControl, lookupItemsOwner);
}
}
}
public PostfixTemplateInfo TryCreateInfo(CSharpPostfixTemplateContext context)
{
var typeExpression = context.TypeExpression;
if (typeExpression == null)
{
return(TryCreateExpressionInfo(context));
}
var typeElement = typeExpression.ReferencedElement as ITypeElement;
if (typeElement == null)
{
return(null);
}
if (context.IsPreciseMode)
{
if (!TypeUtils.IsUsefulToCreateWithNew(typeElement))
{
return(null);
}
}
var canInstantiate = TypeUtils.CanInstantiateType(typeElement, typeExpression.Expression);
if (canInstantiate != CanInstantiate.No)
{
return(new PostfixTemplateInfo("new", typeExpression, PostfixTemplateTarget.TypeUsage));
}
return(null);
}
private static bool IsInstantiableExceptionType([NotNull] IDeclaredType declaredType, [NotNull] ICSharpExpression context)
{
var predefinedType = context.GetPredefinedType();
var conversionRule = context.GetTypeConversionRule();
return(conversionRule.IsImplicitlyConvertibleTo(declaredType, predefinedType.Exception) &&
TypeUtils.CanInstantiateType(declaredType, context) != CanInstantiate.No);
}
public VarByTypeItem([NotNull] PrefixExpressionContext context, [NotNull] IDeclaredType referencedType)
: base("var", context)
{
myReferencedType = referencedType;
myLookupItemsOwner = context.PostfixContext.ExecutionContext.LookupItemsOwner;
var canInstantiate = TypeUtils.CanInstantiateType(referencedType, context.Expression);
myHasRequiredArguments = (canInstantiate & CanInstantiate.ConstructorWithParameters) != 0;
}
private static IPostfixLookupItem CreateExpressionItem([NotNull] PostfixTemplateContext context)
{
var expressionContext = context.InnerExpression;
if (expressionContext == null)
{
return(null);
}
var invocationExpression = expressionContext.Expression as IInvocationExpression;
if (invocationExpression != null) // StringBuilder().new
{
var reference = invocationExpression.InvokedExpression as IReferenceExpression;
if (reference != null)
{
var declaredElement = reference.Reference.Resolve().DeclaredElement;
if (context.IsAutoCompletion)
{
var typeElement = declaredElement as ITypeElement;
if (typeElement != null && TypeUtils.IsUsefulToCreateWithNew(typeElement))
{
var canInstantiate = TypeUtils.CanInstantiateType(typeElement, reference);
if (canInstantiate != CanInstantiate.No)
{
return(new NewExpressionItem(expressionContext));
}
}
}
else if (declaredElement == null || declaredElement is ITypeElement)
{
if (CommonUtils.IsReferenceExpressionsChain(reference))
{
return(new NewExpressionItem(expressionContext));
}
}
}
}
else if (!context.IsAutoCompletion) // UnresolvedType.new
{
var reference = expressionContext.Expression as IReferenceExpression;
if (reference != null && CommonUtils.IsReferenceExpressionsChain(reference))
{
var declaredElement = reference.Reference.Resolve().DeclaredElement;
if (declaredElement == null || declaredElement is ITypeElement)
{
return(new NewTypeItem(expressionContext, hasRequiredArguments: true));
}
}
}
return(null);
}
protected override void AfterComplete(ITextControl textControl, IObjectCreationExpression expression)
{
var referencedType = CSharpTypeFactory.CreateDeclaredType(expression.CreatedTypeUsage);
var canInstantiate = TypeUtils.CanInstantiateType(referencedType, expression);
if ((canInstantiate & CanInstantiate.ConstructorWithParameters) != 0)
{
var lparRange = expression.LPar.GetDocumentRange();
var rparRange = expression.RPar.GetDocumentRange();
var documentRange = lparRange.SetEndTo(rparRange.TextRange.EndOffset);
var argumentsMarker = documentRange.CreateRangeMarker();
var settingsStore = expression.GetSettingsStore();
var invokeParameterInfo = settingsStore.GetValue(PostfixTemplatesSettingsAccessor.InvokeParameterInfo);
var solution = expression.GetSolution();
ExecuteRefactoring(textControl, expression, executeAfter: () =>
{
var argumentsRange = argumentsMarker.Range;
if (!argumentsRange.IsValid)
{
return;
}
var offset = argumentsRange.StartOffset + argumentsRange.Length / 2; // EWW
textControl.Caret.MoveTo(offset, CaretVisualPlacement.DontScrollIfVisible);
if (invokeParameterInfo)
{
var lookupItemsOwner = Info.ExecutionContext.LookupItemsOwner;
LookupUtil.ShowParameterInfo(solution, textControl, lookupItemsOwner);
}
});
}
else
{
ExecuteRefactoring(textControl, expression);
}
}
public IPostfixLookupItem CreateItem(PostfixTemplateContext context)
{
var expressionContext = context.TypeExpression ?? context.OuterExpression;
if (expressionContext == null || !expressionContext.CanBeStatement)
{
return(null);
}
var expression = expressionContext.Expression;
var referencedType = expressionContext.ReferencedType;
if (referencedType != null) // 'Exception.throw' case
{
if (context.IsAutoCompletion && !IsInstantiableExceptionType(referencedType, expression))
{
return(null);
}
var canInstantiate = TypeUtils.CanInstantiateType(referencedType, expression);
var hasParameters = (canInstantiate & CanInstantiate.ConstructorWithParameters) != 0;
return(new ThrowByTypeItem(expressionContext, hasParameters));
}
bool needFixWithNew;
if (CheckExpressionType(expressionContext, out needFixWithNew) || !context.IsAutoCompletion)
{
var reference = expressionContext.Expression as IReferenceExpression;
if (reference != null && CommonUtils.IsReferenceExpressionsChain(reference))
{
return(new ThrowByTypeItem(expressionContext, hasRequiredArguments: true));
}
return(new ThrowExpressionItem(expressionContext, needFixWithNew));
}
return(null);
}
public IPostfixLookupItem CreateItem(PostfixTemplateContext context)
{
var contexts = new List <PrefixExpressionContext>();
foreach (var expressionContext in context.ExpressionsOrTypes)
{
var expression = expressionContext.Expression;
if (expression is IReferenceExpression)
{
// filter out 'too simple' local variable expressions
var target = expressionContext.ReferencedElement;
if (target is IParameter || target is ILocalVariable)
{
if (context.IsAutoCompletion)
{
continue;
}
}
}
else if (expression is IAssignmentExpression)
{
if (context.IsAutoCompletion)
{
continue;
}
}
if (expressionContext.Type.IsVoid())
{
continue;
}
var referencedType = expressionContext.ReferencedType;
if (referencedType != null)
{
if (context.IsAutoCompletion)
{
if (TypeUtils.CanInstantiateType(referencedType, expression) == 0)
{
break;
}
if (!TypeUtils.IsUsefulToCreateWithNew(referencedType.GetTypeElement()))
{
break;
}
}
contexts.Add(expressionContext);
break; // prevent from 'expr == T.var' => 'var t = expr == T;'
}
contexts.Add(expressionContext);
}
var bestContext = contexts.FirstOrDefault(MattersToShowVar) ?? contexts.LastOrDefault();
if (bestContext == null)
{
return(null);
}
if (MattersToShowVar(bestContext) || !context.IsAutoCompletion)
{
var referencedType = bestContext.ReferencedType;
if (referencedType != null)
{
return(new VarByTypeItem(bestContext, referencedType));
}
var isConstructorCall = IsConstructorInvocation(bestContext.Expression);
if (bestContext.CanBeStatement)
{
return(new VarStatementItem(bestContext, isConstructorCall));
}
return(new VarExpressionItem(bestContext, isConstructorCall));
}
return(null);
}
public PostfixTemplateInfo TryCreateInfo(CSharpPostfixTemplateContext context)
{
var contexts = new List <CSharpPostfixExpressionContext>();
foreach (CSharpPostfixExpressionContext expressionContext in context.AllExpressions)
{
var expression = expressionContext.Expression;
if (expression is IReferenceExpression)
{
// filter out 'too simple' local variable expressions
var target = expressionContext.ReferencedElement;
if (target is IParameter || target is ILocalVariable)
{
if (context.IsPreciseMode)
{
continue;
}
}
}
else if (expression is IAssignmentExpression)
{
if (context.IsPreciseMode)
{
continue;
}
}
if (expressionContext.Type.IsVoid())
{
continue;
}
var referencedType = expressionContext.ReferencedType;
if (referencedType != null)
{
if (context.IsPreciseMode)
{
if (TypeUtils.CanInstantiateType(referencedType, expression) == 0)
{
break;
}
if (!TypeUtils.IsUsefulToCreateWithNew(referencedType.GetTypeElement()))
{
break;
}
}
contexts.Add(expressionContext);
break; // prevent from 'expr == T.var' => 'var t = expr == T;'
}
contexts.Add(expressionContext);
}
var bestContext = contexts.FirstOrDefault(IsItMattersToShowVar) ?? contexts.LastOrDefault();
if (bestContext != null)
{
if (IsItMattersToShowVar(bestContext) || !context.IsPreciseMode)
{
var referencedType = bestContext.ReferencedType;
if (referencedType != null)
{
return(new PostfixTemplateInfo("var", bestContext, target: PostfixTemplateTarget.TypeUsage));
}
if (bestContext.CanBeStatement)
{
return(new PostfixTemplateInfo("var", bestContext, target: PostfixTemplateTarget.Statement));
}
return(new PostfixTemplateInfo("var", bestContext));
}
}
return(null);
}
private static PostfixTemplateInfo TryCreateExpressionInfo([NotNull] CSharpPostfixTemplateContext context)
{
var expressionContext = context.InnerExpression;
if (expressionContext == null)
{
return(null);
}
var invocationExpression = expressionContext.Expression as IInvocationExpression;
if (invocationExpression != null)
{
var reference = invocationExpression.InvokedExpression as IReferenceExpression;
if (reference != null)
{
var resolveResult = reference.Reference.Resolve();
var declaredElement = resolveResult.DeclaredElement;
if (context.IsPreciseMode)
{
var typeElement = declaredElement as ITypeElement;
if (typeElement != null && TypeUtils.IsUsefulToCreateWithNew(typeElement))
{
var canInstantiate = TypeUtils.CanInstantiateType(typeElement, reference);
if (canInstantiate != CanInstantiate.No)
{
return(new PostfixTemplateInfo("new", expressionContext));
}
}
}
else if (declaredElement == null || declaredElement is ITypeElement)
{
if (CSharpPostfixUtis.IsReferenceExpressionsChain(reference))
{
return(new PostfixTemplateInfo("new", expressionContext));
}
}
}
return(null);
}
if (!context.IsPreciseMode) // UnresolvedType.new
{
var reference = expressionContext.Expression as IReferenceExpression;
if (reference != null && CSharpPostfixUtis.IsReferenceExpressionsChain(reference))
{
var resolveResult = reference.Reference.Resolve();
var declaredElement = resolveResult.DeclaredElement;
if (declaredElement == null || declaredElement is ITypeElement)
{
// hasRequiredArguments: true
return(new PostfixTemplateInfo("new", expressionContext, PostfixTemplateTarget.TypeUsage));
}
}
}
return(null);
}