public PostfixTemplateInfo TryCreateInfo(CSharpPostfixTemplateContext 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.IsPreciseMode && !IsInstantiableExceptionType(referencedType, expression))
{
return(null);
}
return(new PostfixTemplateInfo("throw", expressionContext, target: PostfixTemplateTarget.TypeUsage));
}
bool needFixWithNew;
if (CheckExpressionType(expressionContext, out needFixWithNew) || !context.IsPreciseMode)
{
var reference = expressionContext.Expression as IReferenceExpression;
if (reference != null && CSharpPostfixUtis.IsReferenceExpressionsChain(reference))
{
return(new PostfixTemplateInfo("throw", expressionContext, target: PostfixTemplateTarget.TypeUsage));
}
var info = new PostfixTemplateInfo("throw", expressionContext);
if (needFixWithNew)
{
info.PutData(NeedFixWithNewKey, info);
}
return(info);
}
return(null);
}
private static bool CheckExpressionType([NotNull] CSharpPostfixExpressionContext expressionContext, out bool needFixWithNew)
{
needFixWithNew = false;
// 'new Exception().throw' case
var expressionType = expressionContext.ExpressionType;
if (expressionType.IsResolved)
{
var predefinedType = expressionContext.Expression.GetPredefinedType();
var conversionRule = expressionContext.Expression.GetTypeConversionRule();
return(expressionType.IsImplicitlyConvertibleTo(predefinedType.Exception, conversionRule));
}
// 'Exception(message).new' case
var invocationExpression = expressionContext.Expression as IInvocationExpression;
if (invocationExpression != null)
{
var reference = invocationExpression.InvokedExpression as IReferenceExpression;
if (reference == null || !CSharpPostfixUtis.IsReferenceExpressionsChain(reference))
{
return(false);
}
var resolveResult = reference.Reference.Resolve().Result;
var typeElement = resolveResult.DeclaredElement as ITypeElement;
if (typeElement == null)
{
return(false);
}
var declaredType = TypeFactory.CreateType(typeElement, resolveResult.Substitution);
if (IsInstantiableExceptionType(declaredType, expressionContext.Expression))
{
needFixWithNew = true;
return(true);
}
}
return(false);
}
private static bool IsConstructorInvocation([NotNull] ICSharpExpression expression)
{
// check for expressions like 'StringBuilder().new'
var invocationExpression = expression as IInvocationExpression;
if (invocationExpression == null)
{
return(false);
}
var reference = invocationExpression.InvokedExpression as IReferenceExpression;
if (reference != null && CSharpPostfixUtis.IsReferenceExpressionsChain(reference))
{
var resolveResult = reference.Reference.Resolve().Result;
return(resolveResult.DeclaredElement is ITypeElement);
}
return(false);
}
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);
}