public static DomReturnType ConvertToReturnType(this TypeReference typeRef)
{
if (typeRef == null)
{
return(null);
}
DomReturnType result;
if (typeRef is InnerClassTypeReference)
{
InnerClassTypeReference innerTypeRef = (InnerClassTypeReference)typeRef;
result = innerTypeRef.BaseType.ConvertToReturnType();
result.Parts.Add(new ReturnTypePart(typeRef.Type));
}
else
{
result = new DomReturnType(typeRef.Type);
}
foreach (TypeReference genericArgument in typeRef.GenericTypes)
{
result.AddTypeParameter(ConvertToReturnType(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 InnerClassTypeReferencTest()
{
InnerClassTypeReference ictr = new InnerClassTypeReference(
new TypeReference("OuterClass", new List<TypeReference> { new TypeReference("String") }),
"InnerClass",
new List<TypeReference> { new TypeReference("Int32"), new TypeReference("Int64") });
Assert.AreEqual("OuterClass<String>+InnerClass<Int32,Int64>", ictr.ToString());
CodeTypeOfExpression result = (CodeTypeOfExpression)new TypeOfExpression(ictr).AcceptVisitor(new CodeDomVisitor(), null);
Assert.AreEqual("OuterClass`1+InnerClass`2", result.Type.BaseType);
Assert.AreEqual(3, result.Type.TypeArguments.Count);
}
public void CSharpNestedGenericFieldReferenceExpressionTest()
{
FieldReferenceExpression fre = ParseUtilCSharp.ParseExpression <FieldReferenceExpression>("MyType<string>.InnerClass<int>.myField");
Assert.AreEqual("myField", fre.FieldName);
Assert.IsTrue(fre.TargetObject is TypeReferenceExpression);
InnerClassTypeReference ic = (InnerClassTypeReference)((TypeReferenceExpression)fre.TargetObject).TypeReference;
Assert.AreEqual("InnerClass", ic.Type);
Assert.AreEqual(1, ic.GenericTypes.Count);
Assert.AreEqual("System.Int32", ic.GenericTypes[0].SystemType);
Assert.AreEqual("MyType", ic.BaseType.Type);
Assert.AreEqual(1, ic.BaseType.GenericTypes.Count);
Assert.AreEqual("System.String", ic.BaseType.GenericTypes[0].SystemType);
}
public void VBNestedGenericTypeOfExpressionTest()
{
TypeOfExpression toe = ParseUtilVBNet.ParseExpression <TypeOfExpression>("GetType(MyType(Of string).InnerClass(of integer).InnerInnerClass)");
InnerClassTypeReference ic = (InnerClassTypeReference)toe.TypeReference;
Assert.AreEqual("InnerInnerClass", ic.Type);
Assert.AreEqual(0, ic.GenericTypes.Count);
ic = (InnerClassTypeReference)ic.BaseType;
Assert.AreEqual("InnerClass", ic.Type);
Assert.AreEqual(1, ic.GenericTypes.Count);
Assert.AreEqual("System.Int32", ic.GenericTypes[0].Type);
Assert.AreEqual("MyType", ic.BaseType.Type);
Assert.AreEqual(1, ic.BaseType.GenericTypes.Count);
Assert.AreEqual("System.String", ic.BaseType.GenericTypes[0].Type);
}
public void CSharpNestedGenericTypeOfExpressionTest()
{
TypeOfExpression toe = ParseUtilCSharp.ParseExpression <TypeOfExpression>("typeof(MyType<string>.InnerClass<int>.InnerInnerClass)");
InnerClassTypeReference ic = (InnerClassTypeReference)toe.TypeReference;
Assert.AreEqual("InnerInnerClass", ic.Type);
Assert.AreEqual(0, ic.GenericTypes.Count);
ic = (InnerClassTypeReference)ic.BaseType;
Assert.AreEqual("InnerClass", ic.Type);
Assert.AreEqual(1, ic.GenericTypes.Count);
Assert.AreEqual("System.Int32", ic.GenericTypes[0].Type);
Assert.AreEqual("MyType", ic.BaseType.Type);
Assert.AreEqual(1, ic.BaseType.GenericTypes.Count);
Assert.AreEqual("System.String", ic.BaseType.GenericTypes[0].Type);
}
public void CSharpNestedGenericLocalVariableDeclarationTest()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement <LocalVariableDeclaration>("MyType<string>.InnerClass<int>.InnerInnerClass a;");
Assert.AreEqual(1, lvd.Variables.Count);
InnerClassTypeReference ic = (InnerClassTypeReference)lvd.GetTypeForVariable(0);
Assert.AreEqual("InnerInnerClass", ic.Type);
Assert.AreEqual(0, ic.GenericTypes.Count);
ic = (InnerClassTypeReference)ic.BaseType;
Assert.AreEqual("InnerClass", ic.Type);
Assert.AreEqual(1, ic.GenericTypes.Count);
Assert.AreEqual("System.Int32", ic.GenericTypes[0].Type);
Assert.AreEqual("MyType", ic.BaseType.Type);
Assert.AreEqual(1, ic.BaseType.GenericTypes.Count);
Assert.AreEqual("System.String", ic.BaseType.GenericTypes[0].Type);
}
public void VBNetNestedGenericLocalVariableDeclarationTest()
{
LocalVariableDeclaration lvd = ParseUtilVBNet.ParseStatement <LocalVariableDeclaration>("Dim a as MyType(of string).InnerClass(of integer).InnerInnerClass");
Assert.AreEqual(1, lvd.Variables.Count);
InnerClassTypeReference ic = (InnerClassTypeReference)lvd.GetTypeForVariable(0);
Assert.AreEqual("InnerInnerClass", ic.Type);
Assert.AreEqual(0, ic.GenericTypes.Count);
ic = (InnerClassTypeReference)ic.BaseType;
Assert.AreEqual("InnerClass", ic.Type);
Assert.AreEqual(1, ic.GenericTypes.Count);
Assert.AreEqual("System.Int32", ic.GenericTypes[0].Type);
Assert.AreEqual("MyType", ic.BaseType.Type);
Assert.AreEqual(1, ic.BaseType.GenericTypes.Count);
Assert.AreEqual("System.String", ic.BaseType.GenericTypes[0].Type);
}
public void InvocationOnGenericInnerClassInGenericType()
{
InvocationExpression expr = ParseUtilCSharp.ParseExpression <InvocationExpression>("A<T>.B.C<U>.Foo()");
MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject;
Assert.AreEqual("Foo", mre.MemberName);
TypeReferenceExpression tre = (TypeReferenceExpression)mre.TargetObject;
InnerClassTypeReference ictr = (InnerClassTypeReference)tre.TypeReference;
Assert.AreEqual("B.C", ictr.Type);
Assert.AreEqual(1, ictr.GenericTypes.Count);
Assert.AreEqual("U", ictr.GenericTypes[0].Type);
Assert.AreEqual("A", ictr.BaseType.Type);
Assert.AreEqual(1, ictr.BaseType.GenericTypes.Count);
Assert.AreEqual("T", ictr.BaseType.GenericTypes[0].Type);
}
private TypeReferenceExpression GetTypeReferenceExpression(Expression expr, List <TypeReference> genericTypes)
{
TypeReferenceExpression tre = expr as TypeReferenceExpression;
if (tre != null)
{
return(new TypeReferenceExpression(new TypeReference(tre.TypeReference.Type, tre.TypeReference.PointerNestingLevel, tre.TypeReference.RankSpecifier, genericTypes)));
}
StringBuilder b = new StringBuilder();
if (!WriteFullTypeName(b, expr))
{
// there is some TypeReferenceExpression hidden in the expression
while (expr is FieldReferenceExpression)
{
expr = ((FieldReferenceExpression)expr).TargetObject;
}
tre = expr as TypeReferenceExpression;
if (tre != null)
{
TypeReference typeRef = tre.TypeReference;
if (typeRef.GenericTypes.Count == 0)
{
typeRef = typeRef.Clone();
typeRef.Type += "." + b.ToString();
typeRef.GenericTypes.AddRange(genericTypes);
}
else
{
typeRef = new InnerClassTypeReference(typeRef, b.ToString(), genericTypes);
}
return(new TypeReferenceExpression(typeRef));
}
}
return(new TypeReferenceExpression(new TypeReference(b.ToString(), 0, null, genericTypes)));
}
public virtual object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data)
{
throw new global::System.NotImplementedException("InnerClassTypeReference");
}
public object VisitInnerClassTypeReference(InnerClassTypeReference typeReference, object data)
{
return(ConvertTypeReference(typeReference));
}
public virtual object Visit(InnerClassTypeReference innerClassTypeReference, object data)
{
Debug.Assert(innerClassTypeReference != null);
return(data);
}
private void TypeName(out TypeReference typeRef, bool canBeUnbound)
{
List<TypeReference> types = null;
string val = null;
string str2;
if ((this.la.kind == 1) && (this.Peek(1).kind == 10))
{
base.lexer.NextToken();
val = this.t.val;
base.Expect(10);
}
this.Qualident(out str2);
if (this.la.kind == 0x17)
{
this.TypeArgumentList(out types, canBeUnbound);
}
if (val == null)
{
typeRef = new TypeReference(str2, types);
}
else if (val == "global")
{
typeRef = new TypeReference(str2, types);
typeRef.IsGlobal = true;
}
else
{
typeRef = new TypeReference(val + "." + str2, types);
}
while (this.DotAndIdent())
{
base.Expect(15);
types = null;
this.Qualident(out str2);
if (this.la.kind == 0x17)
{
this.TypeArgumentList(out types, canBeUnbound);
}
typeRef = new InnerClassTypeReference(typeRef, str2, types);
}
}
public sealed override object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
BeginVisit(innerClassTypeReference);
object result = TrackedVisitInnerClassTypeReference(innerClassTypeReference, data);
EndVisit(innerClassTypeReference);
return result;
}
void TypeName(
#line 2292 "cs.ATG"
out TypeReference typeRef, bool canBeUnbound) {
#line 2293 "cs.ATG"
List<TypeReference> typeArguments = null;
string alias = null;
string qualident;
Location startLocation = la.Location;
if (
#line 2299 "cs.ATG"
IdentAndDoubleColon()) {
Identifier();
#line 2300 "cs.ATG"
alias = t.val;
Expect(10);
}
Qualident(
#line 2303 "cs.ATG"
out qualident);
if (la.kind == 23) {
TypeArgumentList(
#line 2304 "cs.ATG"
out typeArguments, canBeUnbound);
}
#line 2306 "cs.ATG"
if (alias == null) {
typeRef = new TypeReference(qualident, typeArguments);
} else if (alias == "global") {
typeRef = new TypeReference(qualident, typeArguments);
typeRef.IsGlobal = true;
} else {
typeRef = new TypeReference(alias + "." + qualident, typeArguments);
}
while (
#line 2315 "cs.ATG"
DotAndIdent()) {
Expect(15);
#line 2316 "cs.ATG"
typeArguments = null;
Qualident(
#line 2317 "cs.ATG"
out qualident);
if (la.kind == 23) {
TypeArgumentList(
#line 2318 "cs.ATG"
out typeArguments, canBeUnbound);
}
#line 2319 "cs.ATG"
typeRef = new InnerClassTypeReference(typeRef, qualident, typeArguments);
}
#line 2321 "cs.ATG"
typeRef.StartLocation = startLocation;
}
public virtual object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
Debug.Assert((innerClassTypeReference != null));
Debug.Assert((innerClassTypeReference.GenericTypes != null));
Debug.Assert((innerClassTypeReference.BaseType != null));
for (int i = 0; i < innerClassTypeReference.GenericTypes.Count; i++) {
TypeReference o = innerClassTypeReference.GenericTypes[i];
Debug.Assert(o != null);
nodeStack.Push(o);
o.AcceptVisitor(this, data);
o = (TypeReference)nodeStack.Pop();
if (o == null)
innerClassTypeReference.GenericTypes.RemoveAt(i--);
else
innerClassTypeReference.GenericTypes[i] = o;
}
nodeStack.Push(innerClassTypeReference.BaseType);
innerClassTypeReference.BaseType.AcceptVisitor(this, data);
innerClassTypeReference.BaseType = ((TypeReference)(nodeStack.Pop()));
return null;
}
public virtual object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
Debug.Assert((innerClassTypeReference != null));
Debug.Assert((innerClassTypeReference.GenericTypes != null));
Debug.Assert((innerClassTypeReference.BaseType != null));
foreach (TypeReference o in innerClassTypeReference.GenericTypes) {
Debug.Assert(o != null);
o.AcceptVisitor(this, data);
}
return innerClassTypeReference.BaseType.AcceptVisitor(this, data);
}
public object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data)
{
throw new NotImplementedException();
}
public virtual object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
throw new global::System.NotImplementedException("InnerClassTypeReference");
}
void NonArrayTypeName(
#line 2420 "VBNET.ATG"
out TypeReference typeref, bool canBeUnbound) {
#line 2422 "VBNET.ATG"
string name;
typeref = null;
bool isGlobal = false;
if (StartOf(10)) {
if (la.kind == 117) {
lexer.NextToken();
Expect(16);
#line 2427 "VBNET.ATG"
isGlobal = true;
}
QualIdentAndTypeArguments(
#line 2428 "VBNET.ATG"
out typeref, canBeUnbound);
#line 2429 "VBNET.ATG"
typeref.IsGlobal = isGlobal;
while (la.kind == 16) {
lexer.NextToken();
#line 2430 "VBNET.ATG"
TypeReference nestedTypeRef;
QualIdentAndTypeArguments(
#line 2431 "VBNET.ATG"
out nestedTypeRef, canBeUnbound);
#line 2432 "VBNET.ATG"
typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes);
}
} else if (la.kind == 154) {
lexer.NextToken();
#line 2435 "VBNET.ATG"
typeref = new TypeReference("System.Object", true);
if (la.kind == 21) {
lexer.NextToken();
#line 2439 "VBNET.ATG"
List<TypeReference> typeArguments = new List<TypeReference>(1);
if (typeref != null) typeArguments.Add(typeref);
typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
}
} else if (StartOf(11)) {
PrimitiveTypeName(
#line 2445 "VBNET.ATG"
out name);
#line 2445 "VBNET.ATG"
typeref = new TypeReference(name, true);
if (la.kind == 21) {
lexer.NextToken();
#line 2449 "VBNET.ATG"
List<TypeReference> typeArguments = new List<TypeReference>(1);
if (typeref != null) typeArguments.Add(typeref);
typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
}
} else SynErr(236);
}
private TypeReferenceExpression GetTypeReferenceExpression(Expression expr, List<TypeReference> genericTypes)
{
TypeReferenceExpression expression = expr as TypeReferenceExpression;
if (expression != null)
{
return new TypeReferenceExpression(new TypeReference(expression.TypeReference.Type, expression.TypeReference.PointerNestingLevel, expression.TypeReference.RankSpecifier, genericTypes));
}
StringBuilder b = new StringBuilder();
if (!this.WriteFullTypeName(b, expr))
{
while (expr is FieldReferenceExpression)
{
expr = ((FieldReferenceExpression) expr).TargetObject;
}
expression = expr as TypeReferenceExpression;
if (expression != null)
{
TypeReference typeReference = expression.TypeReference;
if (typeReference.GenericTypes.Count == 0)
{
typeReference = typeReference.Clone();
typeReference.Type = typeReference.Type + "." + b.ToString();
typeReference.GenericTypes.AddRange(genericTypes);
}
else
{
typeReference = new InnerClassTypeReference(typeReference, b.ToString(), genericTypes);
}
return new TypeReferenceExpression(typeReference);
}
}
return new TypeReferenceExpression(new TypeReference(b.ToString(), 0, null, genericTypes));
}
public override object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data)
{
return(base.VisitInnerClassTypeReference(innerClassTypeReference, data));
}
public virtual object TrackedVisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
return base.VisitInnerClassTypeReference(innerClassTypeReference, data);
}
