void EmitExpression(CodeExpression expr)
{
if (expr is CodeMethodInvokeExpression)
EmitInvoke((CodeMethodInvokeExpression)expr);
else if (expr is CodeArrayCreateExpression)
EmitArray((CodeArrayCreateExpression)expr);
else if (expr is CodePrimitiveExpression)
EmitPrimitive((CodePrimitiveExpression)expr);
else if (expr is CodeBinaryOperatorExpression)
EmitBinary((CodeBinaryOperatorExpression)expr);
else if (expr is CodeTernaryOperatorExpression)
EmitTernary((CodeTernaryOperatorExpression)expr);
else if (expr is CodeVariableReferenceExpression)
EmitVariableReference((CodeVariableReferenceExpression)expr);
else if (expr is CodeArgumentReferenceExpression)
EmitArgumentReference((CodeArgumentReferenceExpression)expr);
else if (expr is CodeFieldReferenceExpression)
EmitFieldReference((CodeFieldReferenceExpression)expr);
else if (expr is CodeTypeReferenceExpression)
EmitTypeReference((CodeTypeReferenceExpression)expr);
else if (expr is CodeArrayIndexerExpression)
EmitArrayIndexer((CodeArrayIndexerExpression)expr);
else if (expr is CodePropertyReferenceExpression)
EmitPropertyReference((CodePropertyReferenceExpression)expr);
else
throw new ArgumentException("Unrecognised expression: " + expr.GetType());
}
public IExpression GetExpression(CodeExpression expression, CodeGeneratorOptions options)
{
if (expression==null)
{
throw new ArgumentNullException("expression");
}
return _expressionMap[expression.GetType()](expression, options);
}
public static bool Match(CodeExpression firstExpression, CodeExpression secondExpression)
{
if ((firstExpression == null) && (secondExpression == null))
{
return true;
}
if ((firstExpression == null) || (secondExpression == null))
{
return false;
}
if (firstExpression.GetType() != secondExpression.GetType())
{
return false;
}
return GetExpression(firstExpression).Match(firstExpression, secondExpression);
}
private static RuleExpressionInternal GetExpression(CodeExpression expression)
{
Type type = expression.GetType();
int length = typeWrappers.Length;
for (int i = 0; i < length; i++)
{
TypeWrapperTuple tuple = typeWrappers[i];
if (type == tuple.codeDomType)
{
return tuple.internalExpression;
}
}
IRuleExpression ruleExpr = expression as IRuleExpression;
if (ruleExpr != null)
{
return new CustomExpressionWrapper(ruleExpr);
}
return null;
}
private CodeTypeReference GetCodeTypeReferenceInCodeExpression(CodeExpression expression)
{
if (typeof(CodeTypeOfExpression) == expression.GetType())
{
return ((CodeTypeOfExpression)expression).Type;
}
if (typeof(CodeTypeReferenceExpression) == expression.GetType())
{
return ((CodeTypeReferenceExpression)expression).Type;
}
if (typeof(CodeFieldReferenceExpression) == expression.GetType())
{
return GetCodeTypeReferenceInCodeExpression(((CodeFieldReferenceExpression)expression).TargetObject);
}
if (typeof(CodeObjectCreateExpression) == expression.GetType())
{
return ((CodeObjectCreateExpression)expression).CreateType;
}
if (typeof(CodeCastExpression) == expression.GetType())
{
return ((CodeCastExpression)expression).TargetType;
}
if (typeof(CodeMethodInvokeExpression) == expression.GetType())
{
return GetCodeTypeReferenceInCodeExpression(((CodeMethodInvokeExpression)expression).Method);
}
if (typeof(CodeMethodReferenceExpression) == expression.GetType())
{
return GetCodeTypeReferenceInCodeExpression(((CodeMethodReferenceExpression)expression).TargetObject);
}
return null;
}
private static object GetValue (RuleExecution execution, CodeExpression obj)
{
if (obj.GetType () == typeof (System.CodeDom.CodePrimitiveExpression)) {
return (((System.CodeDom.CodePrimitiveExpression) obj).Value);
}
if (obj.GetType () == typeof (CodeFieldReferenceExpression)) {
return RuleExpressionCondition.CodeFieldReferenceValue (execution, obj);
}
if (obj.GetType () == typeof (CodePropertyReferenceExpression)) {
return RuleExpressionCondition.CodePropertyReferenceValue (execution, obj);
}
return null;
}
public void GenerateExpression(CodeExpression expression)
{
if (expression is CodeArrayIndexerExpression)
GenerateArrayIndexerExpression((CodeArrayIndexerExpression)expression);
else if (expression is CodeBinaryOperatorExpression)
GenerateBinaryOperatorExpression((CodeBinaryOperatorExpression)expression);
else if (expression is CodeCastExpression)
GenerateCastExpression((CodeCastExpression)expression);
else if (expression is CodeDelegateCreateExpression)
GenerateDelegateCreateExpression((CodeDelegateCreateExpression)expression);
else if (expression is CodeFieldReferenceExpression)
GenerateFieldReferenceExpression((CodeFieldReferenceExpression)expression);
else if (expression is CodeMethodInvokeExpression)
GenerateMethodInvokeExpression((CodeMethodInvokeExpression)expression);
else if (expression is CodeMethodReferenceExpression)
GenerateMethodReferenceExpression((CodeMethodReferenceExpression)expression);
else if (expression is CodeObjectCreateExpression)
GenerateObjectCreateExpression((CodeObjectCreateExpression)expression);
else if (expression is CodePrimitiveExpression)
GeneratePrimitiveExpression((CodePrimitiveExpression)expression);
else if (expression is CodePropertyReferenceExpression)
GeneratePropertyReferenceExpression((CodePropertyReferenceExpression)expression);
else if (expression is CodeThisReferenceExpression)
GenerateThisReferenceExpression((CodeThisReferenceExpression)expression);
else if (expression is CodeTypeOfExpression)
GenerateTypeOfExpression((CodeTypeOfExpression)expression);
else if (expression is CodeArrayCreateExpression)
GenerateArrayCreateExpression((CodeArrayCreateExpression)expression);
else if (expression is CodeTypeReferenceExpression)
GenerateTypeReferenceExpression((CodeTypeReferenceExpression)expression);
else
throw new NotSupportedException(expression.GetType().ToString());
}
/// <summary>
/// Track down the real type of a CodeExpression's target.
/// </summary>
/// <param name="targetObject"></param>
/// <param name="thisType"></param>
/// <returns></returns>
private static Type FindTargetType(CodeExpression targetObject, Type thisType)
{
Type targetType = GetType(targetObject, false);
if (targetType != null)
{
return targetType;
}
else if (targetObject is CodeVariableReferenceExpression)
{
throw new ApplicationException("Cannot determine the type of a CodeVariableReferenceExpression: " + Serialize(targetObject));
}
else if (targetObject is CodeTypeOfExpression)
{
// Results in a System.Type.
return typeof(Type);
}
else if (targetObject is CodeThisReferenceExpression)
{
if (thisType == null)
{
throw new ApplicationException("There is a CodeThisReferenceExpression and the thisType supplied was null.");
}
return thisType;
}
else if (targetObject is CodePrimitiveExpression)
{
return ((CodePrimitiveExpression)targetObject).Value.GetType();
}
else if (targetObject is CodePropertyReferenceExpression)
{
Type toExamine = FindTargetType(((CodePropertyReferenceExpression)targetObject).TargetObject, thisType);
PropertyInfo propInfo = toExamine.GetProperty(((CodePropertyReferenceExpression)targetObject).PropertyName);
return propInfo.PropertyType;
}
else if (targetObject is CodeMethodInvokeExpression)
{
Type toExamine = FindTargetType(((CodeMethodInvokeExpression)targetObject).Method.TargetObject, thisType);
MethodInfo methodInfo = toExamine.GetMethod(((CodeMethodInvokeExpression)targetObject).Method.MethodName);
return methodInfo.ReturnType;
}
else if (targetObject is CodeFieldReferenceExpression)
{
Type toExamine = FindTargetType(((CodeFieldReferenceExpression)targetObject).TargetObject, thisType);
String fieldName = ((CodeFieldReferenceExpression)targetObject).FieldName;
FieldInfo fieldInfo = toExamine.GetField(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
return fieldInfo.FieldType;
}
else if (targetObject is CodeTypeReferenceExpression)
{
CodeTypeReference typeReference = ((CodeTypeReferenceExpression)targetObject).Type;
return thisType.Assembly.GetType(typeReference.BaseType);
}
throw new NotSupportedException("Specified CodeExpression type is not currently supported: " + targetObject.GetType().FullName);
}
private static void PrintExpression(TextWriter output, CodeExpression expression)
{
if (expression is CodeMethodInvokeExpression)
{
CodeMethodInvokeExpression cmi = (CodeMethodInvokeExpression)expression;
if (cmi.Method.TargetObject == null)
output.Write("defaultscope");
else
PrintExpression(output, cmi.Method.TargetObject);
output.Write('.');
output.Write(cmi.Method.MethodName);
output.Write('(');
for (int i = 0; i < cmi.Parameters.Count; ++i)
{
if (i > 0)
output.Write(", ");
PrintExpression(output, cmi.Parameters[i]);
}
output.Write(')');
return;
}
if (expression is CodeDelegateInvokeExpression)
{
CodeDelegateInvokeExpression die = (CodeDelegateInvokeExpression)expression;
output.Write("delegatecall(");
PrintExpression(output, die.TargetObject);
output.Write(')');
output.Write('(');
for (int i = 0; i < die.Parameters.Count; ++i)
{
if (i > 0)
output.Write(", ");
PrintExpression(output, die.Parameters[i]);
}
output.Write(')');
return;
}
if (expression is CodePropertyReferenceExpression)
{
CodePropertyReferenceExpression cpre = (CodePropertyReferenceExpression)expression;
if (cpre.TargetObject == null)
output.Write("defaultscope");
else
PrintExpression(output, cpre.TargetObject);
output.Write('.');
output.Write(cpre.PropertyName);
return;
}
if (expression is CodeFieldReferenceExpression)
{
CodeFieldReferenceExpression cpre = (CodeFieldReferenceExpression)expression;
if (cpre.TargetObject == null)
output.Write("defaultscope");
else
PrintExpression(output, cpre.TargetObject);
output.Write('.');
output.Write(cpre.FieldName);
output.Write('$');
return;
}
if (expression is CodePrimitiveExpression)
{
object value = ((CodePrimitiveExpression)expression).Value;
if (value == null)
output.Write("null");
else if (value.Equals(true))
output.Write("true");
else if (value.Equals(false))
output.Write("false");
else if (value is string)
output.Write("'{0}'", value.ToString().Replace("'", "\\'"));
else
output.Write("{0}", value);
return;
}
if (expression is CodeThisReferenceExpression)
{
output.Write("this");
return;
}
if (expression is CodeBaseReferenceExpression)
{
output.Write("base");
return;
}
if (expression is CodeArgumentReferenceExpression)
{
output.Write("arg({0})", ((CodeArgumentReferenceExpression)expression).ParameterName);
return;
}
if (expression is CodeVariableReferenceExpression)
{
output.Write("var({0})", ((CodeVariableReferenceExpression)expression).VariableName);
return;
}
if (expression is CodeTypeReferenceExpression)
{
output.Write("typeref(");
CodeTypeReferenceExpression ctr = (CodeTypeReferenceExpression)expression;
PrintTypeReference(output, ctr.Type);
output.Write(')');
return;
}
if (expression is CodeCastExpression)
{
CodeCastExpression cce = expression as CodeCastExpression;
output.Write("cast(");
PrintTypeReference(output, cce.TargetType);
output.Write(", ");
PrintExpression(output, cce.Expression);
output.Write(')');
return;
}
if (expression is CodeTypeOfExpression)
{
CodeTypeOfExpression ctoe = (CodeTypeOfExpression)expression;
output.Write("typeof(");
PrintTypeReference(output, ctoe.Type);
output.Write(')');
return;
}
if (expression is CodeObjectCreateExpression)
{
CodeObjectCreateExpression coce = (CodeObjectCreateExpression)expression;
output.Write("new ");
PrintTypeReference(output, coce.CreateType);
output.Write('(');
for (int i = 0; i < coce.Parameters.Count; ++i)
{
if (i > 0)
output.Write(", ");
PrintExpression(output, coce.Parameters[i]);
}
output.Write(')');
return;
}
if (expression is CodeArrayIndexerExpression)
{
CodeArrayIndexerExpression caie = (CodeArrayIndexerExpression)expression;
output.Write("arrayitem(");
PrintExpression(output, caie.TargetObject);
for (int i = 0; i < caie.Indices.Count; ++i)
{
output.Write(", ");
PrintExpression(output, caie.Indices[i]);
}
output.Write(')');
return;
}
if (expression is CodeArrayCreateExpression)
{
CodeArrayCreateExpression cace = (CodeArrayCreateExpression)expression;
output.Write("newarray(");
PrintTypeReference(output, cace.CreateType);
output.Write(',');
PrintExpression(output, cace.SizeExpression);
output.Write(')');
return;
}
if (expression is CodeBinaryOperatorExpression)
{
CodeBinaryOperatorExpression cboe = (CodeBinaryOperatorExpression)expression;
switch (cboe.Operator)
{
case CodeBinaryOperatorType.ValueEquality:
output.Write("equals");
break;
case CodeBinaryOperatorType.IdentityEquality:
output.Write("refequal");
break;
case CodeBinaryOperatorType.IdentityInequality:
output.Write("refnotequal");
break;
case CodeBinaryOperatorType.Add:
output.Write("add");
break;
default:
output.Write("UNKNOWN CBOE: {0}", cboe.Operator);
break;
}
output.Write('(');
PrintExpression(output, cboe.Left);
output.Write(", ");
PrintExpression(output, cboe.Right);
output.Write(')');
return;
}
if (expression is CodePropertySetValueReferenceExpression)
{
output.Write("setvalue");
return;
}
if (expression is CodeDirectionExpression)
{
switch (((CodeDirectionExpression)expression).Direction)
{
case FieldDirection.In:
PrintExpression(output, ((CodeDirectionExpression)expression).Expression);
break;
case FieldDirection.Out:
output.Write("out(");
PrintExpression(output, ((CodeDirectionExpression)expression).Expression);
output.Write(')');
break;
case FieldDirection.Ref:
output.Write("ref(");
PrintExpression(output, ((CodeDirectionExpression)expression).Expression);
output.Write(')');
break;
}
return;
}
output.Write("*** UNKNOWN EXPRESSION:" + expression.GetType() + " ***");
}
/// <devdoc>
/// <para>Generates code for the specified CodeDom code expression representation.</para>
/// </devdoc>
private void GenerateExpression(CodeExpression e) {
if (e is CodeArrayCreateExpression) {
GenerateArrayCreateExpression((CodeArrayCreateExpression)e);
}
else if (e is CodeBaseReferenceExpression) {
GenerateBaseReferenceExpression((CodeBaseReferenceExpression)e);
}
else if (e is CodeBinaryOperatorExpression) {
GenerateBinaryOperatorExpression((CodeBinaryOperatorExpression)e);
}
else if (e is CodeCastExpression) {
GenerateCastExpression((CodeCastExpression)e);
}
else if (e is CodeDelegateCreateExpression) {
GenerateDelegateCreateExpression((CodeDelegateCreateExpression)e);
}
else if (e is CodeFieldReferenceExpression) {
GenerateFieldReferenceExpression((CodeFieldReferenceExpression)e);
}
else if (e is CodeArgumentReferenceExpression) {
GenerateArgumentReferenceExpression((CodeArgumentReferenceExpression)e);
}
else if (e is CodeVariableReferenceExpression) {
GenerateVariableReferenceExpression((CodeVariableReferenceExpression)e);
}
else if (e is CodeIndexerExpression) {
GenerateIndexerExpression((CodeIndexerExpression)e);
}
else if (e is CodeArrayIndexerExpression) {
GenerateArrayIndexerExpression((CodeArrayIndexerExpression)e);
}
else if (e is CodeSnippetExpression) {
GenerateSnippetExpression((CodeSnippetExpression)e);
}
else if (e is CodeMethodInvokeExpression) {
GenerateMethodInvokeExpression((CodeMethodInvokeExpression)e);
}
else if (e is CodeMethodReferenceExpression) {
GenerateMethodReferenceExpression((CodeMethodReferenceExpression)e);
}
else if (e is CodeEventReferenceExpression) {
GenerateEventReferenceExpression((CodeEventReferenceExpression)e);
}
else if (e is CodeDelegateInvokeExpression) {
GenerateDelegateInvokeExpression((CodeDelegateInvokeExpression)e);
}
else if (e is CodeObjectCreateExpression) {
GenerateObjectCreateExpression((CodeObjectCreateExpression)e);
}
else if (e is CodeParameterDeclarationExpression) {
GenerateParameterDeclarationExpression((CodeParameterDeclarationExpression)e);
}
else if (e is CodeDirectionExpression) {
GenerateDirectionExpression((CodeDirectionExpression)e);
}
else if (e is CodePrimitiveExpression) {
GeneratePrimitiveExpression((CodePrimitiveExpression)e);
}
else if (e is CodePropertyReferenceExpression) {
GeneratePropertyReferenceExpression((CodePropertyReferenceExpression)e);
}
else if (e is CodePropertySetValueReferenceExpression) {
GeneratePropertySetValueReferenceExpression((CodePropertySetValueReferenceExpression)e);
}
else if (e is CodeThisReferenceExpression) {
GenerateThisReferenceExpression((CodeThisReferenceExpression)e);
}
else if (e is CodeTypeReferenceExpression) {
GenerateTypeReferenceExpression((CodeTypeReferenceExpression)e);
}
else if (e is CodeTypeOfExpression) {
GenerateTypeOfExpression((CodeTypeOfExpression)e);
}
else if (e is CodeDefaultValueExpression) {
GenerateDefaultValueExpression((CodeDefaultValueExpression)e);
}
else {
if (e == null) {
throw new ArgumentNullException("e");
}
else {
throw new ArgumentException(SR.GetString(SR.InvalidElementType, e.GetType().FullName), "e");
}
}
}
public static RuleExpressionInfo Validate(RuleValidation validation, CodeExpression expression, bool isWritten)
{
if (validation == null)
{
throw new ArgumentNullException("validation");
}
RuleExpressionInfo info = null;
if (!isWritten)
{
info = validation.ExpressionInfo(expression);
}
if (info != null)
{
return info;
}
RuleExpressionInternal ruleExpr = GetExpression(expression);
if (ruleExpr == null)
{
ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression.GetType().FullName }), 0x548);
item.UserData["ErrorObject"] = expression;
if (validation.Errors == null)
{
string name = string.Empty;
if ((validation.ThisType != null) && (validation.ThisType.Name != null))
{
name = validation.ThisType.Name;
}
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ErrorsCollectionMissing, new object[] { name }));
}
validation.Errors.Add(item);
return null;
}
return validation.ValidateSubexpression(expression, ruleExpr, isWritten);
}
private object MatchArgument(Type parameterType, CodeExpression arg)
{
Type argExprType = arg.GetType();
if (TypeProvider.IsAssignable(parameterType, argExprType))
{
// The argument expression type is assignable to the parameter type,
// so it goes through unscathed.
return arg;
}
else
{
// See if the argument is a constant value, whose type is compatible with
// the parameter.
CodePrimitiveExpression argPrimitive = arg as CodePrimitiveExpression;
if (argPrimitive != null)
{
ValidationError error = null;
Type argPrimitiveType = validation.ExpressionInfo(argPrimitive).ExpressionType;
if (RuleValidation.TypesAreAssignable(argPrimitiveType, parameterType, argPrimitive, out error))
{
// The constant expression's type matched the parameter, so
// use the actual primitive's value as the argument.
return argPrimitive.Value;
}
}
}
return null;
}
private CodeExpression TryGetCachedExpression (IDesignerSerializationManager manager, object value,
CodeExpression parentExpression, object presetValue)
{
CodeExpression expression = null;
if (value != null) // in order to support null value serialization
expression = base.GetExpression (manager, value);
if (expression == null) {
if (parentExpression == null)
manager.Context.Push (new ExpressionContext (null, null, value, presetValue));
else
manager.Context.Push (new ExpressionContext (parentExpression, parentExpression.GetType (), value, presetValue));
expression = base.SerializeToExpression (manager, value);
manager.Context.Pop ();
}
return expression;
}
private Expression Translate(CodeExpression expr){
if (expr == null) return null;
if (expr is CodeArgumentReferenceExpression) return this.Translate((CodeArgumentReferenceExpression)expr);
if (expr is CodeArrayCreateExpression) return this.Translate((CodeArrayCreateExpression)expr);
if (expr is CodeArrayIndexerExpression) return this.Translate((CodeArrayIndexerExpression)expr);
if (expr is CodeBaseReferenceExpression) return this.Translate((CodeBaseReferenceExpression)expr);
if (expr is CodeBinaryOperatorExpression) return this.Translate((CodeBinaryOperatorExpression)expr);
if (expr is CodeCastExpression) return this.Translate((CodeCastExpression)expr);
if (expr is CodeDelegateCreateExpression) return this.Translate((CodeDelegateCreateExpression)expr);
if (expr is CodeDelegateInvokeExpression) return this.Translate((CodeDelegateInvokeExpression)expr);
if (expr is CodeDirectionExpression) return this.Translate((CodeDirectionExpression)expr);
if (expr is CodeEventReferenceExpression) return this.Translate((CodeEventReferenceExpression)expr);
if (expr is CodeFieldReferenceExpression) return this.Translate((CodeFieldReferenceExpression)expr);
if (expr is CodeIndexerExpression) return this.Translate((CodeIndexerExpression)expr);
if (expr is CodeMethodInvokeExpression) return this.Translate((CodeMethodInvokeExpression)expr);
if (expr is CodeMethodReferenceExpression) return this.Translate((CodeMethodReferenceExpression)expr);
if (expr is CodeObjectCreateExpression) return this.Translate((CodeObjectCreateExpression)expr);
if (expr is CodePrimitiveExpression) return this.Translate((CodePrimitiveExpression)expr);
if (expr is CodePropertyReferenceExpression) return this.Translate((CodePropertyReferenceExpression)expr);
if (expr is CodePropertySetValueReferenceExpression) return this.Translate((CodePropertySetValueReferenceExpression)expr);
if (expr is CodeSnippetExpression) return this.Translate((CodeSnippetExpression)expr);
if (expr is CodeThisReferenceExpression) return this.Translate((CodeThisReferenceExpression)expr);
if (expr is CodeTypeOfExpression) return this.Translate((CodeTypeOfExpression)expr);
if (expr is CodeTypeReferenceExpression) return this.Translate((CodeTypeReferenceExpression)expr);
if (expr is CodeVariableReferenceExpression) return this.Translate((CodeVariableReferenceExpression)expr);
Debug.Assert(false);
this.HandleError(Error.DidNotExpect, expr.GetType().FullName);
return null;
}
private static Operation GetPrecedence(CodeExpression expression)
{
// Assume the operation needs no parentheses.
Operation operation = Operation.NoParentheses;
ComputePrecedence computePrecedence;
if (precedenceMap.TryGetValue(expression.GetType(), out computePrecedence))
operation = computePrecedence(expression);
return operation;
}
private void RefactorFieldNamesInFieldReferences(CodeExpression expression, string newName)
{
// Do we have a field reference in the expression we are given?
if(typeof(CodeFieldReferenceExpression) != expression.GetType())
{
return;
}
CodeFieldReferenceExpression frefStatement = (CodeFieldReferenceExpression)expression;
// Is target object of field reference referring to a variable declaration?
if (typeof(CodeVariableReferenceExpression) == frefStatement.TargetObject.GetType())
{
CodeVariableReferenceExpression vrefStatement = (CodeVariableReferenceExpression)frefStatement.TargetObject;
// Get a reference to the variable declaration statement.
CodeVariableDeclarationStatement vdeclStatement = stackVariables[vrefStatement.VariableName];
// Is this a variable of type we are modifying now?
if (vdeclStatement.Type.BaseType == newName)
{
// Then we can convert the field names to PascalCase.
frefStatement.FieldName = PascalCaseConverterHelper.GetPascalCaseName(frefStatement.FieldName);
}
}
}
/// <summary>
/// Rewrites references to entities with dictionary provider specific CodeDom to do the correct lookup.
/// </summary>
/// <param name="source">the CodeDom Expression to rewrite</param>
/// <param name="didRewrite">indicates whether or not the expression was rewritten</param>
/// <returns>the CodeDom expression appropriate for the dictionary provider</returns>
protected override CodeExpression Rewrite(CodeExpression source, ref bool didRewrite)
{
var propertyRef = source as CodePropertyReferenceExpression;
if (propertyRef != null)
{
return this.RewritePropertyReference(propertyRef, ref didRewrite);
}
var lambdaExpression = source as CodeLambdaExpression;
if (lambdaExpression != null)
{
return this.RewriteLambdaExpression(lambdaExpression, ref didRewrite);
}
var arrayExpression = source as CodeAnonymousArrayExpression;
if (arrayExpression != null)
{
return this.RewriteAnonymousArray(arrayExpression, ref didRewrite);
}
ExceptionUtilities.Assert(
source.GetType().Namespace == typeof(CodeObject).Namespace,
"Taupo-defined code expressions need to be explicitly handled or the base tree rewriter will lose them");
return base.Rewrite(source, ref didRewrite);
}
void VisitCodeExpression(CodeExpression expression)
{
if (expression != null) {
WriteLine("VisitCodeExpression: " + expression.GetType().Name);
CodePrimitiveExpression primitiveExpression = expression as CodePrimitiveExpression;
CodeFieldReferenceExpression fieldReferenceExpression = expression as CodeFieldReferenceExpression;
CodeThisReferenceExpression thisReferenceExpression = expression as CodeThisReferenceExpression;
CodeObjectCreateExpression createExpression = expression as CodeObjectCreateExpression;
CodeBinaryOperatorExpression binaryExpression = expression as CodeBinaryOperatorExpression;
CodeMethodReferenceExpression methodReferenceExpression = expression as CodeMethodReferenceExpression;
CodeMethodInvokeExpression methodInvokeExpression = expression as CodeMethodInvokeExpression;
CodeVariableReferenceExpression variableReferenceExpression = expression as CodeVariableReferenceExpression;
if (primitiveExpression != null) {
VisitCodePrimitiveExpression(primitiveExpression);
} else if (fieldReferenceExpression != null) {
VisitCodeFieldReferenceExpression(fieldReferenceExpression);
} else if (thisReferenceExpression != null) {
VisitCodeThisReferenceExpression(thisReferenceExpression);
} else if (createExpression != null) {
VisitObjectCreateExpression(createExpression);
} else if (binaryExpression != null) {
VisitCodeBinaryOperatorExpression(binaryExpression);
} else if (methodReferenceExpression != null) {
VisitCodeMethodReferenceExpression(methodReferenceExpression);
} else if (methodInvokeExpression != null) {
VisitCodeMethodInvokeExpression(methodInvokeExpression);
} else if (variableReferenceExpression != null) {
VisitCodeVariableReferenceExpression(variableReferenceExpression);
}
} else {
WriteLine("VisitCodeExpression: Null");
}
}
void AppendExpression(CodeExpression expression)
{
if (expression is CodeMethodInvokeExpression) {
AppendMethodInvokeExpression((CodeMethodInvokeExpression)expression);
} else if (expression is CodePropertyReferenceExpression) {
AppendPropertyReferenceExpression((CodePropertyReferenceExpression)expression);
} else if (expression is CodeObjectCreateExpression) {
AppendObjectCreateExpression((CodeObjectCreateExpression)expression);
} else if (expression is CodePrimitiveExpression) {
AppendPrimitiveExpression((CodePrimitiveExpression)expression);
} else if (expression is CodeFieldReferenceExpression) {
AppendFieldReferenceExpression((CodeFieldReferenceExpression)expression);
} else if (expression is CodeThisReferenceExpression) {
AppendThisReferenceExpression();
} else if (expression is CodeTypeReferenceExpression) {
AppendTypeReferenceExpression((CodeTypeReferenceExpression)expression);
} else if (expression is CodeArrayCreateExpression) {
AppendArrayCreateExpression((CodeArrayCreateExpression)expression);
} else if (expression is CodeVariableReferenceExpression) {
AppendVariableReferenceExpression((CodeVariableReferenceExpression)expression);
} else if (expression is CodeDelegateCreateExpression) {
AppendDelegateCreateExpression((CodeDelegateCreateExpression)expression);
} else if (expression is CodeCastExpression) {
AppendCastExpression((CodeCastExpression)expression);
} else if (expression is CodeBinaryOperatorExpression) {
AppendBinaryOperatorExpression((CodeBinaryOperatorExpression)expression);
} else {
Console.WriteLine("AppendExpression: " + expression.GetType().Name);
}
}
public static RuleExpressionInfo Validate(RuleValidation validation, CodeExpression expression, bool isWritten)
{
if (validation == null)
throw new ArgumentNullException("validation");
// See if we've visited this node before.
// Always check if written = true
RuleExpressionInfo resultExprInfo = null;
if (!isWritten)
resultExprInfo = validation.ExpressionInfo(expression);
if (resultExprInfo == null)
{
// First time we've seen this node.
RuleExpressionInternal ruleExpr = GetExpression(expression);
if (ruleExpr == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, expression.GetType().FullName);
ValidationError error = new ValidationError(message, ErrorNumbers.Error_CodeExpressionNotHandled);
error.UserData[RuleUserDataKeys.ErrorObject] = expression;
if (validation.Errors == null)
{
string typeName = string.Empty;
if ((validation.ThisType != null) && (validation.ThisType.Name != null))
{
typeName = validation.ThisType.Name;
}
string exceptionMessage = string.Format(
CultureInfo.CurrentCulture, Messages.ErrorsCollectionMissing, typeName);
throw new InvalidOperationException(exceptionMessage);
}
else
{
validation.Errors.Add(error);
}
return null;
}
resultExprInfo = validation.ValidateSubexpression(expression, ruleExpr, isWritten);
}
return resultExprInfo;
}
protected object DeserializeExpression (IDesignerSerializationManager manager, string name, CodeExpression expression)
{
if (expression == null)
throw new ArgumentNullException ("expression");
if (manager == null)
throw new ArgumentNullException ("manager");
bool errorOccurred = false;
object deserialized = null;
// CodeThisReferenceExpression
//
CodeThisReferenceExpression thisExpr = expression as CodeThisReferenceExpression;
if (thisExpr != null) {
RootContext context = manager.Context[typeof (RootContext)] as RootContext;
if (context != null) {
deserialized = context.Value;
} else {
IDesignerHost host = manager.GetService (typeof (IDesignerHost)) as IDesignerHost;
if (host != null)
deserialized = host.RootComponent;
}
}
// CodeVariableReferenceExpression
//
CodeVariableReferenceExpression varRef = expression as CodeVariableReferenceExpression;
if (deserialized == null && varRef != null) {
deserialized = manager.GetInstance (varRef.VariableName);
if (deserialized == null) {
ReportError (manager, "Variable '" + varRef.VariableName + "' not initialized prior to reference");
errorOccurred = true;
}
}
// CodeFieldReferenceExpression (used for Enum references as well)
//
CodeFieldReferenceExpression fieldRef = expression as CodeFieldReferenceExpression;
if (deserialized == null && fieldRef != null) {
deserialized = manager.GetInstance (fieldRef.FieldName);
if (deserialized == null) {
object fieldHolder = DeserializeExpression (manager, null, fieldRef.TargetObject);
FieldInfo field = null;
if (fieldHolder is Type) // static field
field = ((Type)fieldHolder).GetField (fieldRef.FieldName,
BindingFlags.GetField | BindingFlags.Public | BindingFlags.Static);
else // instance field
field = fieldHolder.GetType().GetField (fieldRef.FieldName,
BindingFlags.GetField | BindingFlags.Public | BindingFlags.Instance);
if (field != null)
deserialized = field.GetValue (fieldHolder);
}
if (deserialized == null)
ReportError (manager, "Field '" + fieldRef.FieldName + "' not initialized prior to reference");
}
// CodePrimitiveExpression
//
CodePrimitiveExpression primitiveExp = expression as CodePrimitiveExpression;
if (deserialized == null && primitiveExp != null)
deserialized = primitiveExp.Value;
// CodePropertyReferenceExpression
//
CodePropertyReferenceExpression propRef = expression as CodePropertyReferenceExpression;
if (deserialized == null && propRef != null) {
object target = DeserializeExpression (manager, null, propRef.TargetObject);
if (target != null && target != _errorMarker) {
bool found = false;
if (target is Type) {
PropertyInfo property = ((Type)target).GetProperty (propRef.PropertyName,
BindingFlags.GetProperty |
BindingFlags.Public | BindingFlags.Static);
if (property != null) {
deserialized = property.GetValue (null, null);
found = true;
}
// NRefactory seems to produce PropertyReferences to reference some fields and enums
//
FieldInfo field = ((Type)target).GetField (propRef.PropertyName,
BindingFlags.GetField | BindingFlags.Public | BindingFlags.Static);
if (field != null) {
deserialized = field.GetValue (null);
found = true;
}
} else {
PropertyDescriptor property = TypeDescriptor.GetProperties (target)[propRef.PropertyName];
if (property != null) {
deserialized = property.GetValue (target);
found = true;
}
FieldInfo field = target.GetType().GetField (propRef.PropertyName,
BindingFlags.GetField | BindingFlags.Public | BindingFlags.Instance);
if (field != null) {
deserialized = field.GetValue (null);
found = true;
}
}
if (!found) {
ReportError (manager, "Missing field '" + propRef.PropertyName + " 'in type " +
(target is Type ? ((Type)target).Name : target.GetType ().Name) + "'");
errorOccurred = true;
}
}
}
// CodeObjectCreateExpression
//
CodeObjectCreateExpression createExpr = expression as CodeObjectCreateExpression;
if (deserialized == null && createExpr != null) {
Type type = manager.GetType (createExpr.CreateType.BaseType);
if (type == null) {
ReportError (manager, "Type '" + createExpr.CreateType.BaseType + "' not found." +
"Are you missing a reference?");
errorOccurred = true;
} else {
object[] arguments = new object[createExpr.Parameters.Count];
for (int i=0; i < createExpr.Parameters.Count; i++) {
arguments[i] = this.DeserializeExpression (manager, null, createExpr.Parameters[i]);
if (arguments[i] == _errorMarker) {
errorOccurred = true;
break;
}
}
if (!errorOccurred) {
bool addToContainer = false;
if (typeof(IComponent).IsAssignableFrom (type))
addToContainer = true;
deserialized = this.DeserializeInstance (manager, type, arguments, name, addToContainer);
if (deserialized == _errorMarker || deserialized == null) {
string info = "Type to create: " + createExpr.CreateType.BaseType + System.Environment.NewLine +
"Name: " + name + System.Environment.NewLine +
"addToContainer: " + addToContainer.ToString () + System.Environment.NewLine +
"Parameters Count: " + createExpr.Parameters.Count + System.Environment.NewLine;
for (int i=0; i < arguments.Length; i++) {
info += "Parameter Number: " + i.ToString () + System.Environment.NewLine +
"Parameter Type: " + (arguments[i] == null ? "null" : arguments[i].GetType ().Name) +
System.Environment.NewLine +
"Parameter '" + i.ToString () + "' Value: " + arguments[i].ToString () + System.Environment.NewLine;
}
ReportError (manager,
"Unable to create an instance of type '" + createExpr.CreateType.BaseType + "'",
info);
errorOccurred = true;
}
}
}
}
// CodeArrayCreateExpression
//
CodeArrayCreateExpression arrayCreateExpr = expression as CodeArrayCreateExpression;
if (deserialized == null && arrayCreateExpr != null) {
Type arrayType = manager.GetType (arrayCreateExpr.CreateType.BaseType);
if (arrayType == null) {
ReportError (manager, "Type '" + arrayCreateExpr.CreateType.BaseType + "' not found." +
"Are you missing a reference?");
errorOccurred = true;
} else {
ArrayList initializers = new ArrayList ();
Type elementType = arrayType.GetElementType ();
deserialized = Array.CreateInstance (arrayType, arrayCreateExpr.Initializers.Count);
for (int i = 0; i < arrayCreateExpr.Initializers.Count; i++) {
object element = this.DeserializeExpression (manager, null, arrayCreateExpr.Initializers[i]);
errorOccurred = (element == _errorMarker);
if (!errorOccurred) {
if (arrayType.IsInstanceOfType (element)) {
initializers.Add (element);
} else {
ReportError (manager,
"Array initializer element type incompatible with array type.",
"Array Type: " + arrayType.Name + System.Environment.NewLine +
"Array Element Type: " + elementType + System.Environment.NewLine +
"Initializer Type: " + (element == null ? "null" : element.GetType ().Name));
errorOccurred = true;
}
}
}
if (!errorOccurred)
initializers.CopyTo ((Array)deserialized, 0);
}
}
// CodeMethodInvokeExpression
//
CodeMethodInvokeExpression methodExpr = expression as CodeMethodInvokeExpression;
if (deserialized == null && methodExpr != null) {
object target = this.DeserializeExpression (manager, null, methodExpr.Method.TargetObject);
object[] parameters = null;
if (target == _errorMarker || target == null) {
errorOccurred = true;
} else {
parameters = new object[methodExpr.Parameters.Count];
for (int i=0; i < methodExpr.Parameters.Count; i++) {
parameters[i] = this.DeserializeExpression (manager, null, methodExpr.Parameters[i]);
if (parameters[i] == _errorMarker) {
errorOccurred = true;
break;
}
}
}
if (!errorOccurred) {
MethodInfo method = null;
if (target is Type) {
method = GetExactMethod ((Type)target, methodExpr.Method.MethodName,
BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
parameters);
} else {
method = GetExactMethod (target.GetType(), methodExpr.Method.MethodName,
BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance,
parameters);
}
if (method != null) {
deserialized = method.Invoke (target, parameters);
} else {
string info =
"Method Name: " + methodExpr.Method.MethodName + System.Environment.NewLine +
"Method is: " + (target is Type ? "static" : "instance") + System.Environment.NewLine +
"Method Holder Type: " + (target is Type ? ((Type)target).Name : target.GetType ().Name) + System.Environment.NewLine +
"Parameters Count: " + methodExpr.Parameters.Count + System.Environment.NewLine +
System.Environment.NewLine;
for (int i = 0; i < parameters.Length; i++) {
info += "Parameter Number: " + i.ToString () + System.Environment.NewLine +
"Parameter Type: " + (parameters[i] == null ? "null" : parameters[i].GetType ().Name) +
System.Environment.NewLine +
"Parameter " + i.ToString () + " Value: " + parameters[i].ToString () + System.Environment.NewLine;
}
ReportError (manager,
"Method '" + methodExpr.Method.MethodName + "' missing in type '" +
(target is Type ? ((Type)target).Name : target.GetType ().Name + "'"),
info);
errorOccurred = true;
}
}
}
// CodeTypeReferenceExpression
//
CodeTypeReferenceExpression typeRef = expression as CodeTypeReferenceExpression;
if (deserialized == null && typeRef != null) {
deserialized = manager.GetType (typeRef.Type.BaseType);
if (deserialized == null) {
ReportError (manager, "Type '" + typeRef.Type.BaseType + "' not found." +
"Are you missing a reference?");
errorOccurred = true;
}
}
// CodeCastExpression
//
CodeCastExpression castExpr = expression as CodeCastExpression;
if (deserialized == null && castExpr != null) {
Type targetType = manager.GetType (castExpr.TargetType.BaseType);
object instance = DeserializeExpression (manager, null, castExpr.Expression);
if (instance != null && instance != _errorMarker && targetType != null) {
IConvertible convertible = instance as IConvertible;
if (convertible != null) {
try {
instance = convertible.ToType (targetType, null);
} catch {
errorOccurred = true;
}
} else {
errorOccurred = true;
}
if (errorOccurred) {
ReportError (manager, "Unable to convert type '" + instance.GetType ().Name +
"' to type '" + castExpr.TargetType.BaseType + "'",
"Target Type: " + castExpr.TargetType.BaseType + System.Environment.NewLine +
"Instance Type: " + (instance == null ? "null" : instance.GetType ().Name) + System.Environment.NewLine +
"Instance Value: " + (instance == null ? "null" : instance.ToString()) + System.Environment.NewLine +
"Instance is IConvertible: " + (instance is IConvertible).ToString());
}
deserialized = instance;
}
}
// CodeBinaryOperatorExpression
//
CodeBinaryOperatorExpression binOperator = expression as CodeBinaryOperatorExpression;
if (deserialized == null && binOperator != null) {
string errorText = null;
IConvertible left = null;
IConvertible right = null;
switch (binOperator.Operator) {
case CodeBinaryOperatorType.BitwiseOr:
left = DeserializeExpression (manager, null, binOperator.Left) as IConvertible;
right = DeserializeExpression (manager, null, binOperator.Right) as IConvertible;
if (left is Enum && right is Enum) {
deserialized = Enum.ToObject (left.GetType (), Convert.ToInt64 (left) | Convert.ToInt64 (right));
} else {
errorText = "CodeBinaryOperatorType.BitwiseOr allowed only on Enum types";
errorOccurred = true;
}
break;
default:
errorText = "Unsupported CodeBinaryOperatorType: " + binOperator.Operator.ToString ();
errorOccurred = true;
break;
}
if (errorOccurred) {
string info = "BinaryOperator Type: " + binOperator.Operator.ToString() + System.Environment.NewLine +
"Left Type: " + (left == null ? "null" : left.GetType().Name) + System.Environment.NewLine +
"Left Value: " + (left == null ? "null" : left.ToString ()) + System.Environment.NewLine +
"Left Expression Type: " + binOperator.Left.GetType ().Name + System.Environment.NewLine +
"Right Type: " + (right == null ? "null" : right.GetType().Name) + System.Environment.NewLine +
"Right Value: " + (right == null ? "null" : right.ToString ()) + System.Environment.NewLine +
"Right Expression Type: " + binOperator.Right.GetType ().Name;
ReportError (manager, errorText, info);
}
}
if (!errorOccurred) {
if (deserialized == null && !(expression is CodePrimitiveExpression) && !(expression is CodeMethodInvokeExpression)) {
ReportError (manager, "Unsupported Expression Type: " + expression.GetType ().Name);
errorOccurred = true;
}
}
if (errorOccurred)
deserialized = _errorMarker;
return deserialized;
}
public static bool Match(CodeExpression firstExpression, CodeExpression secondExpression)
{
// If they're both null, they match.
if (firstExpression == null && secondExpression == null)
return true;
// If only one of them is null, there's no match.
if (firstExpression == null || secondExpression == null)
return false;
if (firstExpression.GetType() != secondExpression.GetType())
return false;
RuleExpressionInternal ruleExpr1 = GetExpression(firstExpression);
return ruleExpr1.Match(firstExpression, secondExpression);
}
protected void GenerateExpression (CodeExpression e)
{
if (e == null)
throw new ArgumentNullException ("e");
try {
e.Accept (visitor);
} catch (NotImplementedException) {
throw new ArgumentException ("Element type " + e.GetType () + " is not supported.", "e");
}
}
private static RuleExpressionInternal GetExpression(CodeExpression expression)
{
Type exprType = expression.GetType();
int numTypeWrappers = typeWrappers.Length;
for (int i = 0; i < numTypeWrappers; ++i)
{
TypeWrapperTuple tuple = typeWrappers[i];
if (exprType == tuple.codeDomType)
return tuple.internalExpression;
}
// It's not a builtin one... try a user extension expression.
IRuleExpression ruleExpr = expression as IRuleExpression;
if (ruleExpr != null)
return new CustomExpressionWrapper(ruleExpr);
return null;
}
private Type EmitExpression(CodeExpression Expression, bool ForceTypes)
{
if (Expression == null)
throw new ArgumentException("Expression can not be null", "Expression");
Depth++;
Debug("Emitting expression");
Type Generated;
if (Expression is CodeMethodInvokeExpression)
{
Generated = EmitMethodInvoke(Expression as CodeMethodInvokeExpression);
}
else if (Expression is CodeArrayCreateExpression)
{
EmitDynamicName(Expression as CodeArrayCreateExpression);
Generated = typeof(string[]);
}
else if (Expression is CodePrimitiveExpression)
{
Generated = EmitPrimitive(Expression as CodePrimitiveExpression);
}
else if (Expression is CodeBinaryOperatorExpression)
{
Generated = EmitBinaryOperator(Expression as CodeBinaryOperatorExpression, ForceTypes);
}
else if (Expression is CodeTernaryOperatorExpression)
{
Generated = EmitTernaryOperator(Expression as CodeTernaryOperatorExpression);
}
else if (Expression is CodeVariableReferenceExpression)
{
Generated = EmitVariableReference(Expression as CodeVariableReferenceExpression);
}
else if (Expression is CodeFieldReferenceExpression)
{
Generated = EmitCodeFieldReference(Expression as CodeFieldReferenceExpression);
}
else if (Expression is CodeArgumentReferenceExpression)
{
EmitArgumentReference(Expression as CodeArgumentReferenceExpression);
Generated = typeof(object[]);
}
else if (Expression is CodeArrayIndexerExpression)
{
EmitArrayIndexerExpression(Expression as CodeArrayIndexerExpression);
Generated = typeof(object);
}
else if (Expression is CodeDelegateCreateExpression)
{
Generated = EmitDelegateCreateExpression((CodeDelegateCreateExpression) Expression);
}
else if (Expression is CodePropertyReferenceExpression)
{
Generated = EmitPropertyReferenceExpression((CodePropertyReferenceExpression) Expression);
}
else
{
Depth++;
Debug("Unhandled expression: " + Expression.GetType());
Generated = null;
Depth--;
}
Depth--;
return Generated;
}
private object MatchArgument(Type parameterType, CodeExpression arg)
{
Type fromType = arg.GetType();
if (TypeProvider.IsAssignable(parameterType, fromType))
{
return arg;
}
CodePrimitiveExpression rhsExpression = arg as CodePrimitiveExpression;
if (rhsExpression != null)
{
ValidationError error = null;
if (RuleValidation.TypesAreAssignable(this.validation.ExpressionInfo(rhsExpression).ExpressionType, parameterType, rhsExpression, out error))
{
return rhsExpression.Value;
}
}
return null;
}
