public void ReadWriteReturnTypeTest()
{
DomReturnType input = new DomReturnType();
input.Name = "Test";
input.Namespace = "Namespace";
input.ArrayDimensions = 5;
input.IsByRef = true;
input.IsNullable = true;
input.PointerNestingLevel = 666;
input.AddTypeParameter(new DomReturnType("System.String"));
input.AddTypeParameter(new DomReturnType("System.Int32"));
MemoryStream ms = new MemoryStream();
BinaryWriter writer = new BinaryWriter(ms);
DomPersistence.Write(writer, DefaultNameEncoder, input);
byte[] bytes = ms.ToArray();
IReturnType result = DomPersistence.ReadReturnType(CreateReader(bytes), DefaultNameDecoder, null);
Assert.AreEqual("Test", result.Name);
Assert.AreEqual("Namespace", result.Namespace);
Assert.AreEqual("Namespace.Test", result.FullName);
Assert.AreEqual(5, result.ArrayDimensions);
Assert.AreEqual(true, result.IsByRef);
Assert.AreEqual(true, result.IsNullable);
Assert.AreEqual("System.String", result.GenericArguments[0].FullName);
Assert.AreEqual("System.Int32", result.GenericArguments[1].FullName);
}
public void InstantiatedMethodByArgumentTest_Complex()
{
// build "T MyMethod<T,S> (S b, KeyValuePair<S, T> a)"
DomMethod method = new DomMethod();
method.Name = "MyMethod";
method.ReturnType = new DomReturnType("T");
method.AddTypeParameter(new TypeParameter("T"));
method.AddTypeParameter(new TypeParameter("S"));
method.Add(new DomParameter(method, "b", new DomReturnType("S")));
DomReturnType returnType = new DomReturnType("KeyValuePair");
returnType.AddTypeParameter(new DomReturnType("T"));
returnType.AddTypeParameter(new DomReturnType("S"));
method.Add(new DomParameter(method, "a", returnType));
// give int, object as param type
List <IReturnType> genArgs = new List <IReturnType> ();
List <IReturnType> args = new List <IReturnType> ();
genArgs.Add(DomReturnType.Int32);
genArgs.Add(DomReturnType.Object);
IMethod instMethod = DomMethod.CreateInstantiatedGenericMethod(method, genArgs, args);
// check
Assert.AreEqual(DomReturnType.Int32.FullName, instMethod.ReturnType.FullName);
Assert.AreEqual(DomReturnType.Object.FullName, instMethod.Parameters[0].ReturnType.FullName);
Assert.AreEqual(DomReturnType.Int32.FullName, instMethod.Parameters[1].ReturnType.GenericArguments[0].FullName);
Assert.AreEqual(DomReturnType.Object.FullName, instMethod.Parameters[1].ReturnType.GenericArguments[1].FullName);
}
public IReturnType GetTypeSafe(Expression expression)
{
ResolveResult result = Resolve(expression);
if (expression is LambdaExpression)
{
var lambda = (LambdaExpression)expression;
var bodyType = GetTypeSafe(lambda.ExpressionBody);
DomReturnType constructedLambdaType = new DomReturnType(bodyType.FullName == DomReturnType.Void.FullName ? "System.Action" : "System.Func");
foreach (var param in lambda.Parameters)
{
var typeParam = GetTypeSafe(param);
// add void place holder for types that can't be resolved.
if (typeParam == null || string.IsNullOrEmpty(typeParam.FullName))
{
typeParam = DomReturnType.Void;
}
constructedLambdaType.AddTypeParameter(typeParam);
}
if (bodyType.FullName != DomReturnType.Void.FullName)
{
constructedLambdaType.AddTypeParameter(bodyType ?? result.ResolvedType);
}
return(constructedLambdaType);
}
return(result.ResolvedType ?? DomReturnType.Void);
}
public void InstantiatedMethodByArgumentTestComplex2()
{
// build "T MyMethod<T> (MyType<T> a)"
DomMethod method = new DomMethod();
method.Name = "MyMethod";
method.ReturnType = new DomReturnType("T");
method.AddTypeParameter(new TypeParameter("T"));
DomReturnType returnType = new DomReturnType("MyType");
returnType.AddTypeParameter(new DomReturnType("T"));
method.Add(new DomParameter(method, "a", returnType));
// give int as param type
List <IReturnType> genArgs = new List <IReturnType> ();
List <IReturnType> args = new List <IReturnType> ();
returnType = new DomReturnType("MyType");
returnType.AddTypeParameter(DomReturnType.Int32);
args.Add(returnType);
IMethod instMethod = DomMethod.CreateInstantiatedGenericMethod(method, genArgs, args);
// check
Assert.AreEqual(DomReturnType.Int32.FullName, instMethod.ReturnType.FullName);
}
public IReturnType GetTypeSafe (Expression expression)
{
ResolveResult result = Resolve (expression);
if (expression is LambdaExpression) {
var lambda = (LambdaExpression)expression;
var bodyType = GetTypeSafe (lambda.ExpressionBody);
DomReturnType constructedLambdaType = new DomReturnType (bodyType.FullName == DomReturnType.Void.FullName ? "System.Action" : "System.Func");
foreach (var param in lambda.Parameters) {
var typeParam = GetTypeSafe (param);
// add void place holder for types that can't be resolved.
if (typeParam == null || string.IsNullOrEmpty (typeParam.FullName))
typeParam = DomReturnType.Void;
constructedLambdaType.AddTypeParameter (typeParam);
}
if (bodyType.FullName != DomReturnType.Void.FullName)
constructedLambdaType.AddTypeParameter (bodyType ?? result.ResolvedType);
return constructedLambdaType;
}
return result.ResolvedType ?? DomReturnType.Void;
}
public void ExtensionMethodTest()
{
// build "T MyMethod<T, S> (this KeyValuePair<T, S> a, S b)"
DomMethod method = new DomMethod();
method.Name = "MyMethod";
method.ReturnType = new DomReturnType("T");
method.AddTypeParameter(new TypeParameter("T"));
method.AddTypeParameter(new TypeParameter("S"));
DomReturnType returnType = new DomReturnType("KeyValuePair");
returnType.AddTypeParameter(new DomReturnType("T"));
returnType.AddTypeParameter(new DomReturnType("S"));
method.Add(new DomParameter(method, "a", returnType));
method.Add(new DomParameter(method, "b", new DomReturnType("S")));
// Build extendet type KeyValuePair<int, object>
DomType type = new DomType("KeyValuePair");
type.AddTypeParameter(new TypeParameter("T"));
type.AddTypeParameter(new TypeParameter("S"));
IType extType = DomType.CreateInstantiatedGenericTypeInternal(type, new IReturnType[] { DomReturnType.Int32, DomReturnType.Object });
Console.WriteLine(extType);
// extend method
List <IReturnType> genArgs = new List <IReturnType> ();
List <IReturnType> args = new List <IReturnType> ();
ExtensionMethod extMethod = new ExtensionMethod(extType, method, genArgs, args);
Console.WriteLine(extMethod);
// check
Assert.AreEqual(DomReturnType.Int32.FullName, extMethod.ReturnType.FullName);
Assert.AreEqual(DomReturnType.Object.FullName, extMethod.Parameters[0].ReturnType.FullName);
}
static IReturnType ConvertTypeReference(TypeReference typeRef)
{
if (typeRef == null)
{
return(null);
}
DomReturnType result = new DomReturnType(typeRef.Type);
foreach (TypeReference genericArgument in typeRef.GenericTypes)
{
result.AddTypeParameter(ConvertTypeReference(genericArgument));
}
result.PointerNestingLevel = typeRef.PointerNestingLevel;
if (typeRef.IsArrayType)
{
result.ArrayDimensions = typeRef.RankSpecifier.Length;
for (int i = 0; i < typeRef.RankSpecifier.Length; i++)
{
result.SetDimension(i, typeRef.RankSpecifier[i]);
}
}
return(result);
}
public override object VisitMemberReferenceExpression (MemberReferenceExpression memberReferenceExpression, object data)
{
if (memberReferenceExpression == null) {
return null;
}
ResolveResult result;
if (String.IsNullOrEmpty (memberReferenceExpression.MemberName)) {
if (memberReferenceExpression.TargetObject is TypeReferenceExpression) {
result = CreateResult (((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference);
result.StaticResolve = true;
return result;
}
// if (memberReferenceExpression.TargetObject is ThisReferenceExpression) {
// result = CreateResult (((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference);
// result.StaticResolve = true;
// return result;
// }
// return memberReferenceExpression.TargetObject.AcceptVisitor(this, data);
}
result = memberReferenceExpression.TargetObject.AcceptVisitor (this, data) as ResolveResult;
NamespaceResolveResult namespaceResult = result as NamespaceResolveResult;
if (namespaceResult != null) {
if (String.IsNullOrEmpty (memberReferenceExpression.MemberName))
return namespaceResult;
string fullName = namespaceResult.Namespace + "." + memberReferenceExpression.MemberName;
if (resolver.Dom.NamespaceExists (fullName, true))
return new NamespaceResolveResult (fullName);
DomReturnType searchType = new DomReturnType (fullName);
if (memberReferenceExpression.TypeArguments != null) {
foreach (TypeReference typeRef in memberReferenceExpression.TypeArguments) {
searchType.AddTypeParameter (NRefactoryResolver.ConvertTypeReference (typeRef));
}
}
IType type = resolver.Dom.GetType (searchType);
if (type != null) {
result = CreateResult (this.resolver.Unit, new DomReturnType (type));
result.StaticResolve = true;
return result;
}
return null;
}
if (result != null && result.ResolvedType != null) {
foreach (ResolveResult innerResult in result.ResolveResults) {
ResolveResult resolvedResult = ResolveMemberReference (innerResult, memberReferenceExpression);
if (resolvedResult != null)
return resolvedResult;
}
} else {
if (result != null)
MonoDevelop.Core.LoggingService.LogWarning ("Couldn't resolve type " + result.ResolvedType);
}
return null;
}
public override object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
{
if (memberReferenceExpression == null)
{
return(null);
}
ResolveResult result;
if (String.IsNullOrEmpty(memberReferenceExpression.MemberName))
{
if (memberReferenceExpression.TargetObject is TypeReferenceExpression)
{
result = CreateResult(((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference);
result.StaticResolve = true;
return(result);
}
// if (memberReferenceExpression.TargetObject is ThisReferenceExpression) {
// result = CreateResult (((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference);
// result.StaticResolve = true;
// return result;
// }
// return memberReferenceExpression.TargetObject.AcceptVisitor(this, data);
}
result = memberReferenceExpression.TargetObject.AcceptVisitor(this, data) as ResolveResult;
NamespaceResolveResult namespaceResult = result as NamespaceResolveResult;
if (namespaceResult != null)
{
if (String.IsNullOrEmpty(memberReferenceExpression.MemberName))
{
return(namespaceResult);
}
string fullName = namespaceResult.Namespace + "." + memberReferenceExpression.MemberName;
if (resolver.Dom.NamespaceExists(fullName, true))
{
return(new NamespaceResolveResult(fullName));
}
DomReturnType searchType = new DomReturnType(fullName);
if (memberReferenceExpression.TypeArguments != null)
{
foreach (TypeReference typeRef in memberReferenceExpression.TypeArguments)
{
searchType.AddTypeParameter(NRefactoryResolver.ConvertTypeReference(typeRef));
}
}
IType type = resolver.Dom.GetType(searchType);
if (type != null)
{
result = CreateResult(this.resolver.Unit, new DomReturnType(type));
result.StaticResolve = true;
return(result);
}
return(null);
}
if (result != null && result.ResolvedType != null)
{
foreach (ResolveResult innerResult in result.ResolveResults)
{
ResolveResult resolvedResult = ResolveMemberReference(innerResult, memberReferenceExpression);
if (resolvedResult != null)
{
return(resolvedResult);
}
}
}
else
{
if (result != null)
{
MonoDevelop.Core.LoggingService.LogWarning("Couldn't resolve type " + result.ResolvedType);
}
}
return(null);
}
public void ExtensionMethodTest ()
{
// build "T MyMethod<T, S> (this KeyValuePair<T, S> a, S b)"
DomMethod method = new DomMethod ();
method.Name = "MyMethod";
method.ReturnType = new DomReturnType ("T");
method.AddTypeParameter (new TypeParameter ("T"));
method.AddTypeParameter (new TypeParameter ("S"));
DomReturnType returnType = new DomReturnType ("KeyValuePair");
returnType.AddTypeParameter (new DomReturnType ("T"));
returnType.AddTypeParameter (new DomReturnType ("S"));
method.Add (new DomParameter (method, "a", returnType));
method.Add (new DomParameter (method, "b", new DomReturnType ("S")));
// Build extendet type KeyValuePair<int, object>
DomType type = new DomType ("KeyValuePair");
type.AddTypeParameter (new TypeParameter ("T"));
type.AddTypeParameter (new TypeParameter ("S"));
IType extType = DomType.CreateInstantiatedGenericTypeInternal (type, new IReturnType[] { DomReturnType.Int32, DomReturnType.Object });
Console.WriteLine (extType);
// extend method
List<IReturnType> genArgs = new List<IReturnType> ();
List<IReturnType> args = new List<IReturnType> ();
ExtensionMethod extMethod = new ExtensionMethod (extType, method, genArgs, args);
Console.WriteLine (extMethod);
// check
Assert.AreEqual (DomReturnType.Int32.FullName, extMethod.ReturnType.FullName);
Assert.AreEqual (DomReturnType.Object.FullName, extMethod.Parameters[0].ReturnType.FullName);
}
public void ReadWriteReturnTypeTest ()
{
DomReturnType input = new DomReturnType ();
input.Name = "Test";
input.Namespace = "Namespace";
input.ArrayDimensions = 5;
input.IsByRef = true;
input.IsNullable = true;
input.PointerNestingLevel = 666;
input.AddTypeParameter (new DomReturnType ("System.String"));
input.AddTypeParameter (new DomReturnType ("System.Int32"));
MemoryStream ms = new MemoryStream ();
BinaryWriter writer = new BinaryWriter (ms);
DomPersistence.Write (writer, DefaultNameEncoder, input);
byte[] bytes = ms.ToArray ();
IReturnType result = DomPersistence.ReadReturnType (CreateReader (bytes), DefaultNameDecoder);
Assert.AreEqual ("Test", result.Name);
Assert.AreEqual ("Namespace", result.Namespace);
Assert.AreEqual ("Namespace.Test", result.FullName);
Assert.AreEqual (5, result.ArrayDimensions);
Assert.AreEqual (true, result.IsByRef);
Assert.AreEqual (true, result.IsNullable);
Assert.AreEqual ("System.String", result.GenericArguments[0].FullName);
Assert.AreEqual ("System.Int32", result.GenericArguments[1].FullName);
}
static IReturnType ConvertTypeReference (TypeReference typeRef)
{
if (typeRef == null)
return null;
DomReturnType result = new DomReturnType (typeRef.Type);
foreach (TypeReference genericArgument in typeRef.GenericTypes) {
result.AddTypeParameter (ConvertTypeReference (genericArgument));
}
result.PointerNestingLevel = typeRef.PointerNestingLevel;
if (typeRef.IsArrayType) {
result.ArrayDimensions = typeRef.RankSpecifier.Length;
for (int i = 0; i < typeRef.RankSpecifier.Length; i++) {
result.SetDimension (i, typeRef.RankSpecifier[i]);
}
}
return result;
}
public void InstantiatedMethodByArgumentTest_Complex ()
{
// build "T MyMethod<T,S> (S b, KeyValuePair<S, T> a)"
DomMethod method = new DomMethod ();
method.Name = "MyMethod";
method.ReturnType = new DomReturnType ("T");
method.AddTypeParameter (new TypeParameter ("T"));
method.AddTypeParameter (new TypeParameter ("S"));
method.Add (new DomParameter (method, "b", new DomReturnType ("S")));
DomReturnType returnType = new DomReturnType ("KeyValuePair");
returnType.AddTypeParameter (new DomReturnType ("T"));
returnType.AddTypeParameter (new DomReturnType ("S"));
method.Add (new DomParameter (method, "a", returnType));
// give int, object as param type
List<IReturnType> genArgs = new List<IReturnType> ();
List<IReturnType> args = new List<IReturnType> ();
genArgs.Add (DomReturnType.Int32);
genArgs.Add (DomReturnType.Object);
IMethod instMethod = DomMethod.CreateInstantiatedGenericMethod (method, genArgs, args);
// check
Assert.AreEqual (DomReturnType.Int32.FullName, instMethod.ReturnType.FullName);
Assert.AreEqual (DomReturnType.Object.FullName, instMethod.Parameters[0].ReturnType.FullName);
Assert.AreEqual (DomReturnType.Int32.FullName, instMethod.Parameters[1].ReturnType.GenericArguments[0].FullName);
Assert.AreEqual (DomReturnType.Object.FullName, instMethod.Parameters[1].ReturnType.GenericArguments[1].FullName);
}
public void InstantiatedMethodByArgumentTestComplex2 ()
{
// build "T MyMethod<T> (MyType<T> a)"
DomMethod method = new DomMethod ();
method.Name = "MyMethod";
method.ReturnType = new DomReturnType ("T");
method.AddTypeParameter (new TypeParameter ("T"));
DomReturnType returnType = new DomReturnType ("MyType");
returnType.AddTypeParameter (new DomReturnType ("T"));
method.Add (new DomParameter (method, "a", returnType));
// give int as param type
List<IReturnType> genArgs = new List<IReturnType> ();
List<IReturnType> args = new List<IReturnType> ();
returnType = new DomReturnType ("MyType");
returnType.AddTypeParameter (DomReturnType.Int32);
args.Add (returnType);
IMethod instMethod = DomMethod.CreateInstantiatedGenericMethod (method, genArgs, args);
// check
Assert.AreEqual (DomReturnType.Int32.FullName, instMethod.ReturnType.FullName);
}
public ExtensionMethod (IType extensionType, IMethod originalMethod, IList<IReturnType> genericArguments, IEnumerable<IReturnType> methodArguments)
{
if (extensionType == null)
throw new ArgumentNullException ("extensionType");
if (originalMethod == null)
throw new ArgumentNullException ("originalMethod");
this.DeclaringType = extensionType;
List<IReturnType> args = new List<IReturnType> ();
if (extensionType.FullName.EndsWith ("[]")) {
foreach (IReturnType returnType in extensionType.BaseTypes) {
if (returnType.FullName == "System.Collections.Generic.IList" && returnType.GenericArguments.Count > 0) {
args.Add (returnType.GenericArguments[0]);
break;
}
}
if (args.Count == 0)
args.Add (new DomReturnType (extensionType));
} else if (extensionType is InstantiatedType) {
InstantiatedType instType = (InstantiatedType)extensionType;
DomReturnType uninstantiatedReturnType = new DomReturnType (instType.UninstantiatedType.FullName);
foreach (IReturnType genArg in instType.GenericParameters) {
uninstantiatedReturnType.AddTypeParameter (genArg);
}
args.Add (uninstantiatedReturnType);
} else {
args.Add (new DomReturnType (extensionType));
}
if (methodArguments != null)
args.AddRange (methodArguments);
// Console.WriteLine ("Create Extension method from:");
// Console.WriteLine ("ext type:" + args[0]);
// Console.WriteLine (originalMethod);
this.method = DomMethod.CreateInstantiatedGenericMethod (originalMethod, genericArguments, args);
// skip first parameter.
for (int i = 1; i < method.Parameters.Count; i++) {
Add (method.Parameters[i]);
}
foreach (ITypeParameter par in method.TypeParameters) {
AddTypeParameter (par);
}
this.ExtensionType = extensionType;
this.OriginalMethod = originalMethod;
//Console.WriteLine (this);
//Console.WriteLine ("oOoOoOoOoOoOoOoOoOoOoOoOoOoO");
}
public static DomReturnType ConvertToReturnType (this AstType typeRef)
{
if (typeRef == null)
return null;
DomReturnType result;
if (typeRef is SimpleType) {
var st = (SimpleType)typeRef;
result = new DomReturnType (st.Identifier);
foreach (var arg in st.TypeArguments){
result.AddTypeParameter (ConvertToReturnType (arg));
}
} else if (typeRef is ICSharpCode.NRefactory.CSharp.MemberType) {
var mt = (ICSharpCode.NRefactory.CSharp.MemberType)typeRef;
result = ConvertToReturnType (mt.Target);
result.Parts.Add (new ReturnTypePart (mt.MemberName));
foreach (var arg in mt.TypeArguments){
result.AddTypeParameter (ConvertToReturnType (arg));
}
} else if (typeRef is ComposedType) {
var ct = (ComposedType)typeRef;
result = ConvertToReturnType (ct.BaseType);
result.PointerNestingLevel = ct.PointerRank;
result.IsNullable = ct.HasNullableSpecifier;
int arraySpecifiers = ct.ArraySpecifiers.Count;
if (arraySpecifiers> 0) {
result.ArrayDimensions = arraySpecifiers;
int i = 0;
foreach (var spec in ct.ArraySpecifiers) {
result.SetDimension (i, spec.Dimensions);
i++;
}
}
} else if (typeRef is PrimitiveType) {
var pt = (PrimitiveType)typeRef;
result = new DomReturnType (pt.Keyword);
} else if (typeRef.IsNull) {
return null;
} else {
throw new InvalidOperationException ("unknown AstType:" + typeRef);
}
return result;
}
void AddTypeArguments (ATypeNameExpression texpr, DomReturnType result)
{
if (!texpr.HasTypeArguments)
return;
foreach (var arg in texpr.TypeArguments.Args) {
result.AddTypeParameter (ConvertReturnType (arg));
}
}
public static DomReturnType ConvertToReturnType(this AstType typeRef)
{
if (typeRef == null)
{
return(null);
}
DomReturnType result;
if (typeRef is SimpleType)
{
var st = (SimpleType)typeRef;
result = new DomReturnType(st.Identifier);
foreach (var arg in st.TypeArguments)
{
result.AddTypeParameter(ConvertToReturnType(arg));
}
}
else if (typeRef is ICSharpCode.NRefactory.CSharp.MemberType)
{
var mt = (ICSharpCode.NRefactory.CSharp.MemberType)typeRef;
result = ConvertToReturnType(mt.Target);
result.Parts.Add(new ReturnTypePart(mt.MemberName));
foreach (var arg in mt.TypeArguments)
{
result.AddTypeParameter(ConvertToReturnType(arg));
}
}
else if (typeRef is ComposedType)
{
var ct = (ComposedType)typeRef;
result = ConvertToReturnType(ct.BaseType);
result.PointerNestingLevel = ct.PointerRank;
result.IsNullable = ct.HasNullableSpecifier;
int arraySpecifiers = ct.ArraySpecifiers.Count;
if (arraySpecifiers > 0)
{
result.ArrayDimensions = arraySpecifiers;
int i = 0;
foreach (var spec in ct.ArraySpecifiers)
{
result.SetDimension(i, spec.Dimensions);
i++;
}
}
}
else if (typeRef is PrimitiveType)
{
var pt = (PrimitiveType)typeRef;
result = new DomReturnType(pt.Keyword);
}
else if (typeRef.IsNull)
{
return(null);
}
else
{
throw new InvalidOperationException("unknown AstType:" + typeRef);
}
return(result);
}
