public static ITranslation For(UnaryExpression cast, ITranslationContext context)
{
var castValueTranslation = context.GetTranslationFor(cast.Operand);
switch (cast.NodeType)
{
case ExpressionType.Convert:
case ConvertChecked:
if (cast.Type == typeof(object))
{
// Don't bother to show a boxing cast:
return(castValueTranslation);
}
if (cast.Method != null)
{
var isImplicitOperator = cast.Method.IsImplicitOperator();
if (isImplicitOperator)
{
return(castValueTranslation.ShouldWriteInParentheses()
? castValueTranslation.WithParentheses()
: castValueTranslation);
}
if (cast.Method.IsExplicitOperator())
{
break;
}
return(MethodCallTranslation.ForCustomMethodCast(
context.GetTranslationFor(cast.Type),
new BclMethodWrapper(cast.Method),
castValueTranslation,
context));
}
if (IsDelegateCast(cast, out var createDelegateCall))
{
return(MethodGroupTranslation.ForCreateDelegateCall(cast.NodeType, createDelegateCall, context));
}
break;
case TypeAs:
return(new TypeTestedTranslation(TypeAs, castValueTranslation, " as ", cast.Type, context));
}
return(new StandardCastTranslation(cast, castValueTranslation, context));
}
private ParameterSetTranslation(
IMethod method,
IEnumerable <Expression> parameters,
int count,
ITranslationContext context)
{
_settings = context.Settings;
_parenthesesMode = ParenthesesMode.Auto;
if (count == 0)
{
_parameterTranslations = Enumerable <CodeBlockTranslation> .EmptyArray;
TranslationSize = _openAndCloseParentheses.Length;
return;
}
var methodProvided = method != null;
if (methodProvided && method.IsExtensionMethod)
{
parameters = parameters.Skip(1);
--count;
}
Count = count;
ParameterInfo[] methodParameters;
if (methodProvided)
{
methodParameters = method.GetParameters();
parameters = GetAllParameters(parameters, methodParameters);
}
else
{
methodParameters = null;
}
var hasSingleParameter = Count == 1;
var singleParameterIsMultiLineLambda = false;
var showParameterTypeNames = context.Settings.ShowLambdaParamTypes;
var translationSize = 0;
var formattingSize = 0;
_parameterTranslations = parameters
.Project((p, index) =>
{
ITranslation translation;
if (CanBeConvertedToMethodGroup(p, out var lambdaBodyMethodCall))
{
translation = new MethodGroupTranslation(
Lambda,
lambdaBodyMethodCall.GetSubjectTranslation(context),
lambdaBodyMethodCall.Method,
context);
goto CreateCodeBlock;
}
if (methodProvided)
{
var parameterIndex = index;
if (Count != count)
{
// If a parameter is a params array then index will increase
// past parameterCount, so adjust here:
parameterIndex -= Count - count;
}
// ReSharper disable once PossibleNullReferenceException
translation = GetParameterTranslation(p, methodParameters[parameterIndex], context);
goto CreateCodeBlock;
}
translation = context.GetTranslationFor(p);
if (showParameterTypeNames &&
(translation is IParameterTranslation parameterTranslation))
{
parameterTranslation.WithTypeNames(context);
WithParentheses();
}
CreateCodeBlock:
translationSize += translation.TranslationSize;
formattingSize += translation.FormattingSize;
// TODO: Only use code blocks where useful:
var parameterCodeBlock = new CodeBlockTranslation(translation, context).WithoutTermination();
if (hasSingleParameter && parameterCodeBlock.IsMultiStatementLambda(context))
{
singleParameterIsMultiLineLambda = true;
parameterCodeBlock.WithSingleLamdaParameterFormatting();
}
return(parameterCodeBlock);
})
.ToArray();
_hasSingleMultiStatementLambdaParameter = singleParameterIsMultiLineLambda;
TranslationSize = translationSize + (Count * ", ".Length) + 4;
FormattingSize = formattingSize;
}
