Value Visit(ConversionResolveResult result)
{
if (result.IsError)
{
throw new GetValueException("Cannot convert from '{0}' to '{1}'.", new CSharpAmbience().ConvertType(result.Input.Type), new CSharpAmbience().ConvertType(result.Type));
}
var val = Convert(result.Input);
if (result.Conversion.IsBoxingConversion)
{
return(val);
}
if (result.Conversion.IsIdentityConversion)
{
return(val);
}
if (result.Conversion.IsNumericConversion)
{
var convVal = CSharpPrimitiveCast.Cast(ReflectionHelper.GetTypeCode(result.Type), val.PrimitiveValue, false);
return(Eval.CreateValue(evalThread, convVal));
}
if (result.Conversion.IsUserDefined)
{
return(InvokeMethod(null, result.Conversion.Method, val));
}
if (result.Conversion.IsReferenceConversion && result.Conversion.IsImplicit)
{
return(val);
}
if (result.Conversion.IsNullLiteralConversion)
{
return(val);
}
throw new GetValueException("conversion '{0}' not implemented!", result.Conversion);
}
bool IsLiteralMatch(object val)
{
if (val == null)
{
return(false);
}
switch (searchTermLiteralType)
{
case TypeCode.Int64:
TypeCode tc = Type.GetTypeCode(val.GetType());
if (tc >= TypeCode.SByte && tc <= TypeCode.UInt64)
{
return(CSharpPrimitiveCast.Cast(TypeCode.Int64, val, false).Equals(searchTermLiteralValue));
}
else
{
return(false);
}
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.String:
return(searchTermLiteralValue.Equals(val));
default:
// substring search with searchTerm
return(IsMatch(t => val.ToString()));
}
}
public Expression ConvertConstantValue(IType type, object constantValue)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (constantValue == null)
{
if (type.IsReferenceType == true)
{
return(new NullReferenceExpression());
}
else
{
return(new DefaultValueExpression(ConvertType(type)));
}
}
else if (type.Kind == TypeKind.Enum)
{
return(ConvertEnumValue(type, (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, constantValue, false)));
}
else
{
return(new PrimitiveExpression(constantValue));
}
}
public LiteralSearchStrategy(params string[] terms)
: base(terms)
{
if (1 == searchTerm.Length)
{
var parser = new CSharpParser();
var pe = parser.ParseExpression(searchTerm[0]) as PrimitiveExpression;
if (pe != null && pe.Value != null)
{
TypeCode peValueType = Type.GetTypeCode(pe.Value.GetType());
switch (peValueType)
{
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
searchTermLiteralType = TypeCode.Int64;
searchTermLiteralValue = CSharpPrimitiveCast.Cast(TypeCode.Int64, pe.Value, false);
break;
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.String:
searchTermLiteralType = peValueType;
searchTermLiteralValue = pe.Value;
break;
}
}
}
}
public LiteralSearchStrategy(Language language, ApiVisibility apiVisibility, IProducerConsumerCollection <SearchResult> resultQueue, params string[] terms)
: base(language, apiVisibility, resultQueue, terms)
{
if (terms.Length == 1)
{
var lexer = new Lexer(new LATextReader(new System.IO.StringReader(terms[0])));
var value = lexer.NextToken();
if (value != null && value.LiteralValue != null)
{
TypeCode valueType = Type.GetTypeCode(value.LiteralValue.GetType());
switch (valueType)
{
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
searchTermLiteralType = TypeCode.Int64;
searchTermLiteralValue = CSharpPrimitiveCast.Cast(TypeCode.Int64, value.LiteralValue, false);
break;
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.String:
searchTermLiteralType = valueType;
searchTermLiteralValue = value.LiteralValue;
break;
}
}
}
}
ConstantResolveResult CreateTypedCaseLabel(long i, IType type, string[] map = null)
{
object value;
// unpack nullable type, if necessary:
// we need to do this in all cases, because there are nullable bools and enum types as well.
type = NullableType.GetUnderlyingType(type);
if (type.IsKnownType(KnownTypeCode.Boolean))
{
value = i != 0;
}
else if (type.IsKnownType(KnownTypeCode.String) && map != null)
{
value = map[i];
}
else if (type.Kind == TypeKind.Enum)
{
var enumType = type.GetDefinition().EnumUnderlyingType;
value = CSharpPrimitiveCast.Cast(ReflectionHelper.GetTypeCode(enumType), i, false);
}
else
{
value = CSharpPrimitiveCast.Cast(ReflectionHelper.GetTypeCode(type), i, false);
}
return(new ConstantResolveResult(type, value));
}
public LiteralSearchStrategy(params string[] terms)
: base(terms)
{
if (searchTerm.Length == 1)
{
var lexer = new Lexer(new LATextReader(new System.IO.StringReader(searchTerm[0])));
var value = lexer.NextToken();
if (value != null && value.LiteralValue != null)
{
TypeCode valueType = Type.GetTypeCode(value.LiteralValue.GetType());
switch (valueType)
{
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
searchTermLiteralType = TypeCode.Int64;
searchTermLiteralValue = CSharpPrimitiveCast.Cast(TypeCode.Int64, value.LiteralValue, false);
break;
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.String:
searchTermLiteralType = valueType;
searchTermLiteralValue = value.LiteralValue;
break;
}
}
}
}
ConstantResolveResult CreateTypedCaseLabel(long i, IType type, string[] map = null)
{
object value;
if (type.IsKnownType(KnownTypeCode.Boolean))
{
value = i != 0;
}
else if (type.IsKnownType(KnownTypeCode.String) && map != null)
{
value = map[i];
}
else if (type.Kind == TypeKind.Enum)
{
var enumType = type.GetDefinition().EnumUnderlyingType;
value = CSharpPrimitiveCast.Cast(ReflectionHelper.GetTypeCode(enumType), i, false);
}
else if (type.IsKnownType(KnownTypeCode.NullableOfT))
{
var nullableType = NullableType.GetUnderlyingType(type);
value = CSharpPrimitiveCast.Cast(ReflectionHelper.GetTypeCode(nullableType), i, false);
}
else
{
value = CSharpPrimitiveCast.Cast(ReflectionHelper.GetTypeCode(type), i, false);
}
return(new ConstantResolveResult(type, value));
}
public void Run()
{
try {
if (searchMode == SearchMode_Literal)
{
if (1 == searchTerm.Length)
{
CSharpParser parser = new CSharpParser();
PrimitiveExpression pe = parser.ParseExpression(searchTerm[0]) as PrimitiveExpression;
if (pe != null && pe.Value != null)
{
TypeCode peValueType = Type.GetTypeCode(pe.Value.GetType());
switch (peValueType)
{
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
searchTermLiteralType = TypeCode.Int64;
searchTermLiteralValue = CSharpPrimitiveCast.Cast(TypeCode.Int64, pe.Value, false);
break;
case TypeCode.Single:
case TypeCode.Double:
case TypeCode.String:
searchTermLiteralType = peValueType;
searchTermLiteralValue = pe.Value;
break;
}
}
}
}
foreach (var loadedAssembly in assemblies)
{
ModuleDefinition module = loadedAssembly.ModuleDefinition;
if (module == null)
{
continue;
}
CancellationToken cancellationToken = cts.Token;
foreach (TypeDefinition type in module.Types)
{
cancellationToken.ThrowIfCancellationRequested();
PerformSearch(type);
}
}
} catch (OperationCanceledException) {
// ignore cancellation
}
// remove the 'Searching...' entry
dispatcher.BeginInvoke(
DispatcherPriority.Normal,
new Action(delegate { this.Results.RemoveAt(this.Results.Count - 1); }));
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var t = value.GetType();
if (t.IsEnum)
{
return((int)CSharpPrimitiveCast.Cast(TypeCode.Int32, value, false));
}
return(value);
}
static object[] MakeConstantArray(ResolveResult[] sizeArguments, ResolveResult[] initializerElements)
{
if (initializerElements == null)
{
return(null);
}
for (int i = 0; i < initializerElements.Length; i++)
{
if (!initializerElements[i].IsCompileTimeConstant)
{
return(null);
}
}
if (sizeArguments != null && sizeArguments.Length > 0)
{
if (sizeArguments.Length > 1)
{
// 2D-arrays can't be constant
return(null);
}
if (!sizeArguments[0].IsCompileTimeConstant)
{
return(null);
}
int expectedSize;
try {
expectedSize = (int)CSharpPrimitiveCast.Cast(TypeCode.Int32, sizeArguments[0].ConstantValue, true);
} catch (InvalidCastException) {
return(null);
} catch (OverflowException) {
return(null);
}
if (expectedSize != initializerElements.Length)
{
return(null);
}
}
object[] constants = new object[initializerElements.Length];
for (int i = 0; i < initializerElements.Length; i++)
{
constants[i] = initializerElements[i].ConstantValue;
}
return(constants);
}
public ResolveResult Resolve(ITypeResolveContext context)
{
ResolveResult rr = baseValue.Resolve(context);
if (rr.IsCompileTimeConstant && rr.ConstantValue != null)
{
object val = rr.ConstantValue;
TypeCode typeCode = Type.GetTypeCode(val.GetType());
if (typeCode >= TypeCode.SByte && typeCode <= TypeCode.UInt64)
{
long intVal = (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, val, false);
object newVal = CSharpPrimitiveCast.Cast(typeCode, unchecked (intVal + incrementAmount), false);
return(new ConstantResolveResult(rr.Type, newVal));
}
}
return(new ErrorResolveResult(rr.Type));
}
public object GetValue(ITypeResolveContext context)
{
object val = baseValue.GetValue(context);
if (val == null)
{
return(null);
}
TypeCode typeCode = Type.GetTypeCode(val.GetType());
if (!(typeCode >= TypeCode.SByte && typeCode <= TypeCode.UInt64))
{
return(null);
}
long intVal = (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, val, false);
return(CSharpPrimitiveCast.Cast(typeCode, unchecked (intVal + incrementAmount), false));
}
CaseLabel CreateTypedCaseLabel(long i, IType type)
{
object value;
if (type.IsKnownType(KnownTypeCode.Boolean))
{
value = i != 0;
}
else if (type.Kind == TypeKind.Enum)
{
var enumType = type.GetDefinition().EnumUnderlyingType;
value = CSharpPrimitiveCast.Cast(ReflectionHelper.GetTypeCode(enumType), i, false);
}
else
{
value = CSharpPrimitiveCast.Cast(ReflectionHelper.GetTypeCode(type), i, false);
}
return(new CaseLabel(exprBuilder.ConvertConstantValue(new ConstantResolveResult(type, value))));
}
static void RunTest(bool checkForOverflow)
{
string mode = checkForOverflow ? "checked" : "unchecked";
foreach (object input in inputValues)
{
string inputType = input.GetType().Name;
foreach (var targetType in targetTypes)
{
try {
object result = CSharpPrimitiveCast.Cast(targetType, input, checkForOverflow);
Console.WriteLine("{0} ({1})({2}){3} = ({4}){5}", mode, targetType, inputType, input,
result.GetType().Name, result);
} catch (Exception ex) {
Console.WriteLine("{0} ({1})({2}){3} = {4}", mode, targetType, inputType, input,
ex.GetType().Name);
}
}
}
}
public static IEnumerable <Flag> GetFlags(Type flagsType, int mask = -1, int selectedValues = 0, string neutralItem = null)
{
if (neutralItem != null)
{
yield return(new Flag(neutralItem, -1, false));
}
foreach (var item in flagsType.GetFields(BindingFlags.Static | BindingFlags.Public))
{
if (item.Name.EndsWith("Mask", StringComparison.Ordinal))
{
continue;
}
int value = (int)CSharpPrimitiveCast.Cast(TypeCode.Int32, item.GetRawConstantValue(), false);
if ((value & mask) == 0)
{
continue;
}
yield return(new Flag($"{item.Name} ({value:X4})", value, (selectedValues & value) != 0));
}
}
public Expression ConvertConstantValue(IType type, object constantValue)
{
if (type == null)
throw new ArgumentNullException("type");
if (constantValue == null) {
if (type.IsReferenceType == true) {
var expr = new NullReferenceExpression();
if (AddResolveResultAnnotations)
expr.AddAnnotation(new ConstantResolveResult(SpecialType.NullType, null));
return expr;
} else {
var expr = new DefaultValueExpression(ConvertType(type));
if (AddResolveResultAnnotations)
expr.AddAnnotation(new ConstantResolveResult(type, null));
return expr;
}
} else if (type.Kind == TypeKind.Enum) {
return ConvertEnumValue(type, (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, constantValue, false));
} else {
return new PrimitiveExpression(constantValue);
}
}
public override void VisitAssignmentExpression(AssignmentExpression assignment)
{
base.VisitAssignmentExpression(assignment);
// Combine "x = x op y" into "x op= y"
BinaryOperatorExpression binary = assignment.Right as BinaryOperatorExpression;
if (binary != null && assignment.Operator == AssignmentOperatorType.Assign)
{
if (CanConvertToCompoundAssignment(assignment.Left) && assignment.Left.IsMatch(binary.Left))
{
assignment.Operator = GetAssignmentOperatorForBinaryOperator(binary.Operator);
if (assignment.Operator != AssignmentOperatorType.Assign)
{
// If we found a shorter operator, get rid of the BinaryOperatorExpression:
assignment.CopyAnnotationsFrom(binary);
assignment.Right = binary.Right;
}
}
}
// TODO: context.Settings.IntroduceIncrementAndDecrement
if (assignment.Operator == AssignmentOperatorType.Add || assignment.Operator == AssignmentOperatorType.Subtract)
{
// detect increment/decrement
var rr = assignment.Right.GetResolveResult();
if (rr.IsCompileTimeConstant && rr.Type.IsCSharpPrimitiveIntegerType() && CSharpPrimitiveCast.Cast(rr.Type.GetTypeCode(), 1, false).Equals(rr.ConstantValue))
{
// only if it's not a custom operator
if (assignment.Annotation <IL.CallInstruction>() == null)
{
UnaryOperatorType type;
// When the parent is an expression statement, pre- or post-increment doesn't matter;
// so we can pick post-increment which is more commonly used (for (int i = 0; i < x; i++))
if (assignment.Parent is ExpressionStatement)
{
type = (assignment.Operator == AssignmentOperatorType.Add) ? UnaryOperatorType.PostIncrement : UnaryOperatorType.PostDecrement;
}
else
{
type = (assignment.Operator == AssignmentOperatorType.Add) ? UnaryOperatorType.Increment : UnaryOperatorType.Decrement;
}
assignment.ReplaceWith(new UnaryOperatorExpression(type, assignment.Left.Detach()).CopyAnnotationsFrom(assignment));
}
}
}
}
Expression ConvertEnumValue(IType type, long val)
{
ITypeDefinition enumDefinition = type.GetDefinition();
TypeCode enumBaseTypeCode = ReflectionHelper.GetTypeCode(enumDefinition.EnumUnderlyingType);
foreach (IField field in enumDefinition.Fields)
{
if (field.IsConst && object.Equals(CSharpPrimitiveCast.Cast(TypeCode.Int64, field.ConstantValue, false), val))
{
return(ConvertType(type).Member(field.Name));
}
}
if (IsFlagsEnum(enumDefinition))
{
long enumValue = val;
Expression expr = null;
long negatedEnumValue = ~val;
// limit negatedEnumValue to the appropriate range
switch (enumBaseTypeCode)
{
case TypeCode.Byte:
case TypeCode.SByte:
negatedEnumValue &= byte.MaxValue;
break;
case TypeCode.Int16:
case TypeCode.UInt16:
negatedEnumValue &= ushort.MaxValue;
break;
case TypeCode.Int32:
case TypeCode.UInt32:
negatedEnumValue &= uint.MaxValue;
break;
}
Expression negatedExpr = null;
foreach (IField field in enumDefinition.Fields.Where(fld => fld.IsConst))
{
long fieldValue = (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, field.ConstantValue, false);
if (fieldValue == 0)
{
continue; // skip None enum value
}
if ((fieldValue & enumValue) == fieldValue)
{
var fieldExpression = ConvertType(type).Member(field.Name);
if (expr == null)
{
expr = fieldExpression;
}
else
{
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.BitwiseOr, fieldExpression);
}
enumValue &= ~fieldValue;
}
if ((fieldValue & negatedEnumValue) == fieldValue)
{
var fieldExpression = ConvertType(type).Member(field.Name);
if (negatedExpr == null)
{
negatedExpr = fieldExpression;
}
else
{
negatedExpr = new BinaryOperatorExpression(negatedExpr, BinaryOperatorType.BitwiseOr, fieldExpression);
}
negatedEnumValue &= ~fieldValue;
}
}
if (enumValue == 0 && expr != null)
{
if (!(negatedEnumValue == 0 && negatedExpr != null && negatedExpr.Descendants.Count() < expr.Descendants.Count()))
{
return(expr);
}
}
if (negatedEnumValue == 0 && negatedExpr != null)
{
return(new UnaryOperatorExpression(UnaryOperatorType.BitNot, negatedExpr));
}
}
return(new PrimitiveExpression(CSharpPrimitiveCast.Cast(enumBaseTypeCode, val, false)).CastTo(ConvertType(type)));
}
