static void _Patch(CodeIndexerExpression indexer, CodeDomVisitContext ctx, CodeDomResolver resolver)
{
if (null != indexer)
{
if (indexer.TargetObject.UserData.Contains("slang:unresolved"))
{
return;
}
var ctr = resolver.GetTypeOfExpression(indexer.TargetObject);
if (null != ctr.ArrayElementType && 0 < ctr.ArrayRank)
{
var ai = new CodeArrayIndexerExpression(indexer.TargetObject);
ai.Indices.AddRange(indexer.Indices);
CodeDomVisitor.ReplaceTarget(ctx, ai);
//return;
}
indexer.UserData.Remove("slang:unresolved");
}
}
static void _Patch(CodeVariableDeclarationStatement vd, CodeDomVisitContext ctx, CodeDomResolver resolver)
{
if (null != vd)
{
if (CodeDomResolver.IsNullOrVoidType(vd.Type) || (0 == vd.Type.ArrayRank && 0 == vd.Type.TypeArguments.Count && 0 == string.Compare("var", vd.Type.BaseType, StringComparison.InvariantCulture)))
{
if (null == vd.InitExpression)
{
throw new ArgumentException(_AppendLineInfo("The code contains an incomplete variable declaration", vd), "resolver");
}
if (!_HasUnresolved(vd.InitExpression))
{
var t = resolver.GetTypeOfExpression(vd.InitExpression, resolver.GetScope(vd.InitExpression));
vd.Type = t;
if (!CodeDomResolver.IsNullOrVoidType(t))
{
vd.UserData.Remove("slang:unresolved");
}
}
}
}
}
static void _Patch(CodeFieldReferenceExpression fr, CodeDomVisitContext ctx, CodeDomResolver resolver)
{
if (null != fr)
{
// this probably means part of our field has been resolved, or at the very least
// it does not come from a rooted var ref.
if (!fr.TargetObject.UserData.Contains("slang:unresolved"))
{
var scope = resolver.GetScope(fr);
var binder = new CodeDomBinder(scope);
var t = resolver.GetTypeOfExpression(fr.TargetObject, scope);
if (null != t && CodeDomResolver.IsNullOrVoidType(t) && fr.TargetObject is CodeVariableReferenceExpression)
{
return; // can't patch this field yet - it's part of a var reference that hasn't been filled in
}
var isStatic = false;
var tre = fr.TargetObject as CodeTypeReferenceExpression;
if (null != tre)
{
isStatic = true;
}
var tt = resolver.TryResolveType(isStatic ? tre.Type : t, scope, true);
if (null == tt)
{
throw new InvalidOperationException(_AppendLineInfo(string.Format("The type {0} could not be resolved", t.BaseType), t));
}
var td = tt as CodeTypeDeclaration;
// TODO: This code could be a lot faster if we added some functionality to the binder
// we're just checking to see if the method, property or field exists
var m = binder.GetField(tt, fr.FieldName, _BindFlags);
if (null != m)
{
fr.UserData.Remove("slang:unresolved");
return;
}
m = binder.GetEvent(tt, fr.FieldName, _BindFlags);
if (null != m)
{
var er = new CodeEventReferenceExpression(fr.TargetObject, fr.FieldName);
CodeDomVisitor.ReplaceTarget(ctx, er);
return;
}
var ml = binder.GetMethodGroup(tt, fr.FieldName, _BindFlags);
if (0 < ml.Length)
{
var mr = new CodeMethodReferenceExpression(fr.TargetObject, fr.FieldName);
CodeDomVisitor.ReplaceTarget(ctx, mr);
return;
}
ml = binder.GetPropertyGroup(tt, fr.FieldName, _BindFlags);
if (0 < ml.Length)
{
var pr = new CodePropertyReferenceExpression(fr.TargetObject, fr.FieldName);
CodeDomVisitor.ReplaceTarget(ctx, pr);
return;
}
throw new InvalidProgramException(_AppendLineInfo(string.Format("Cannot deterimine the target reference {0}", fr.FieldName), fr));
}
// TODO: This used to be first but I moved it here.
// This shouldn't be done first because it's resolving types before fields and
// that is a no no. I still need to make sure it doesn't break things
var path = _GetUnresRootPathOfExpression(fr);
if (null != path)
{
// now we have something to work with.
var scope = resolver.GetScope(fr);
var sa = path.Split('.');
if (1 == sa.Length)
{
System.Diagnostics.Debugger.Break();
throw new NotImplementedException();
}
else
{
object t = null;
string tn = null;
CodeExpression tf = fr;
CodeExpression ptf = null;
CodeTypeReference ctr = null;
for (var i = sa.Length - 1; i >= 1; --i)
{
tn = string.Join(".", sa, 0, i);
ptf = tf;
tf = _GetTargetOfExpression(tf);
ctr = new CodeTypeReference(tn);
t = resolver.TryResolveType(ctr, scope);
if (null != t)
{
break;
}
}
if (null != t)
{
var tt = t as Type;
if (null != tt)
{
ctr = new CodeTypeReference(tt);
}
else
{
ctr = resolver.GetQualifiedType(ctr, scope);
}
// we found a type reference
_SetTargetOfExpression(ptf, new CodeTypeReferenceExpression(ctr));
return;
//args.Cancel = true;
}
}
}
}
}
static void _Patch(CodeBinaryOperatorExpression op, CodeDomVisitContext ctx, CodeDomResolver resolver)
{
if (null != op)
{
//var rf = op.Left as CodeFieldReferenceExpression;
//if (null != rf && rf.FieldName == "Reduce")
// System.Diagnostics.Debugger.Break();
var scope = resolver.GetScope(op);
if (CodeBinaryOperatorType.IdentityEquality == op.Operator)
{
if (_HasUnresolved(op.Left))
{
return;
}
//var vop = op.Right as CodeVariableReferenceExpression;
//if (null != vop && vop.VariableName == "n")
// System.Diagnostics.Debugger.Break();
var tr1 = resolver.GetTypeOfExpression(op.Left);
if (resolver.IsValueType(tr1))
{
if (_HasUnresolved(op.Right))
{
return;
}
var tr2 = resolver.GetTypeOfExpression(op.Right);
if (resolver.IsValueType(tr2))
{
var op2 = new CodeBinaryOperatorExpression(op.Left, CodeBinaryOperatorType.ValueEquality, op.Right);
CodeDomVisitor.ReplaceTarget(ctx, op2);
return;
}
}
op.UserData.Remove("slang:unresolved");
}
else if (CodeBinaryOperatorType.IdentityInequality == op.Operator)
{
if (_HasUnresolved(op.Left))
{
return;
}
var tr1 = resolver.GetTypeOfExpression(op.Left);
if (resolver.IsValueType(tr1))
{
if (_HasUnresolved(op.Right))
{
return;
}
var tr2 = resolver.GetTypeOfExpression(op.Right);
if (resolver.IsValueType(tr2))
{
// we have to hack the codedom because there is no value inequality
op.Operator = CodeBinaryOperatorType.ValueEquality;
var newOp = new CodeBinaryOperatorExpression(new CodePrimitiveExpression(false), CodeBinaryOperatorType.ValueEquality, op);
CodeDomVisitor.ReplaceTarget(ctx, newOp);
}
}
op.UserData.Remove("slang:unresolved");
}
}
}
