public override TypeReference Clone()
{
InnerClassTypeReference c = new InnerClassTypeReference(baseType.Clone(), Type, GenericTypes);
CopyFields(this, c);
return(c);
}
public override TypeReference Clone()
{
InnerClassTypeReference c = new InnerClassTypeReference(baseType.Clone(), Type, new List <TypeReference>());
CopyFields(this, c);
return(c);
}
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 override TypeReference Clone()
{
InnerClassTypeReference c = new InnerClassTypeReference(baseType.Clone(), Type, new List<TypeReference>());
CopyFields(this, c);
return c;
}
public override TypeReference Clone()
{
InnerClassTypeReference c = new InnerClassTypeReference(baseType.Clone(), Type, GenericTypes);
CopyFields(this, c);
return c;
}
public override object TrackedVisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data)
{
Console.WriteLine("VisitInnerClassTypeReference");
return null;
}
public virtual object TrackedVisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
return base.VisitInnerClassTypeReference(innerClassTypeReference, data);
}
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);
}
void TypeName(
#line 2338 "cs.ATG"
out TypeReference typeRef, bool canBeUnbound) {
#line 2339 "cs.ATG"
List<TypeReference> typeArguments = null;
string alias = null;
string qualident;
Location startLocation = la.Location;
if (
#line 2345 "cs.ATG"
IdentAndDoubleColon()) {
Identifier();
#line 2346 "cs.ATG"
alias = t.val;
Expect(10);
}
Qualident(
#line 2349 "cs.ATG"
out qualident);
if (la.kind == 23) {
TypeArgumentList(
#line 2350 "cs.ATG"
out typeArguments, canBeUnbound);
}
#line 2352 "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 2361 "cs.ATG"
DotAndIdent()) {
Expect(15);
#line 2362 "cs.ATG"
typeArguments = null;
Qualident(
#line 2363 "cs.ATG"
out qualident);
if (la.kind == 23) {
TypeArgumentList(
#line 2364 "cs.ATG"
out typeArguments, canBeUnbound);
}
#line 2365 "cs.ATG"
typeRef = new InnerClassTypeReference(typeRef, qualident, typeArguments);
}
#line 2367 "cs.ATG"
typeRef.StartLocation = startLocation; typeRef.EndLocation = t.EndLocation;
}
public object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data)
{
throw new NotImplementedException ();
}
public virtual bool VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object d)
{
if ((innerClassTypeReference == null)) {
return SetFailure();
}
if ((d == null)) {
return SetFailure();
}
if ((innerClassTypeReference.GenericTypes == null)) {
return SetFailure();
}
if ((innerClassTypeReference.BaseType == null)) {
return SetFailure();
}
if(innerClassTypeReference.GetType() != d.GetType()) {return SetFailure();}
var data = (InnerClassTypeReference)d;
if (!IsMatch(innerClassTypeReference, data)) {
return SetFailure();
}
if (innerClassTypeReference.GenericTypes.Count == data.GenericTypes.Count) {
for (int i=0; i<innerClassTypeReference.GenericTypes.Count;i++) {
TypeReference o = innerClassTypeReference.GenericTypes[i];
if(o == null){return SetFailure();}
if((bool)o.AcceptVisitor(this, data.GenericTypes[i]) == false) return SetFailure();
} } else { return SetFailure(); }
return innerClassTypeReference.BaseType.AcceptVisitor(this, data.BaseType);
}
public object VisitInnerClassTypeReference(InnerClassTypeReference typeReference, object data)
{
return ConvertTypeReference(typeReference);
}
void TypeName(
#line 2260 "cs.ATG"
out TypeReference typeRef, bool canBeUnbound) {
#line 2261 "cs.ATG"
List<TypeReference> typeArguments = null;
string alias = null;
string qualident;
if (
#line 2266 "cs.ATG"
IdentAndDoubleColon()) {
Identifier();
#line 2267 "cs.ATG"
alias = t.val;
Expect(10);
}
Qualident(
#line 2270 "cs.ATG"
out qualident);
if (la.kind == 23) {
TypeArgumentList(
#line 2271 "cs.ATG"
out typeArguments, canBeUnbound);
}
#line 2273 "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 2282 "cs.ATG"
DotAndIdent()) {
Expect(15);
#line 2283 "cs.ATG"
typeArguments = null;
Qualident(
#line 2284 "cs.ATG"
out qualident);
if (la.kind == 23) {
TypeArgumentList(
#line 2285 "cs.ATG"
out typeArguments, canBeUnbound);
}
#line 2286 "cs.ATG"
typeRef = new InnerClassTypeReference(typeRef, qualident, typeArguments);
}
}
/// <summary>
/// Converts tree into nested TypeReference/InnerClassTypeReference.
/// Dotted names are split into separate nodes.
/// It does not normalize generic arguments.
/// </summary>
static TypeReference NormalizeTypeReference(this INode expr)
{
if (expr is IdentifierExpression)
{
return(new TypeReference(
((IdentifierExpression)expr).Identifier,
((IdentifierExpression)expr).TypeArguments
));
}
else if (expr is MemberReferenceExpression)
{
TypeReference outter = NormalizeTypeReference(((MemberReferenceExpression)expr).TargetObject);
return(new InnerClassTypeReference(
outter,
((MemberReferenceExpression)expr).MemberName,
((MemberReferenceExpression)expr).TypeArguments
));
}
else if (expr is TypeReferenceExpression)
{
return(NormalizeTypeReference(((TypeReferenceExpression)expr).TypeReference));
}
else if (expr is InnerClassTypeReference) // Frist - it is also TypeReference
{
InnerClassTypeReference typeRef = (InnerClassTypeReference)expr;
string[] names = typeRef.Type.Split('.');
TypeReference newRef = NormalizeTypeReference(typeRef.BaseType);
foreach (string name in names)
{
newRef = new InnerClassTypeReference(newRef, name, new List <TypeReference>());
}
newRef.GenericTypes.AddRange(typeRef.GenericTypes);
newRef.PointerNestingLevel = typeRef.PointerNestingLevel;
newRef.RankSpecifier = typeRef.RankSpecifier;
return(newRef);
}
else if (expr is TypeReference)
{
TypeReference typeRef = (TypeReference)expr;
string[] names = typeRef.Type.Split('.');
if (names.Length == 1)
{
return(typeRef);
}
TypeReference newRef = null;
foreach (string name in names)
{
if (newRef == null)
{
newRef = new TypeReference(name, new List <TypeReference>());
}
else
{
newRef = new InnerClassTypeReference(newRef, name, new List <TypeReference>());
}
}
newRef.GenericTypes.AddRange(typeRef.GenericTypes);
newRef.PointerNestingLevel = typeRef.PointerNestingLevel;
newRef.RankSpecifier = typeRef.RankSpecifier;
return(newRef);
}
else
{
throw new EvaluateException(expr, "Type expected. {0} seen.", expr.GetType().FullName);
}
}
public static TypeReference GetTypeReference(this Type type)
{
List <int> arrayRanks = new List <int>();
while (type.IsArray)
{
// C# uses reverse array order
arrayRanks.Add(type.GetArrayRank() - 1);
type = type.GetElementType();
}
int pointerNest = 0;
while (type.IsPointer)
{
pointerNest++;
type = type.GetElementType();
}
if (type.IsArray)
{
throw new DebuggerException("C# does not support pointers to arrays");
}
string name = type.Name;
if (name.IndexOf('`') != -1)
{
name = name.Substring(0, name.IndexOf('`'));
}
if (!string.IsNullOrEmpty(type.Namespace))
{
name = type.Namespace + "." + name;
}
List <Type> genArgs = new List <Type>();
// This inludes the generic arguments of the outter types
genArgs.AddRange(type.GetGenericArguments());
if (type.DeclaringType != null)
{
genArgs.RemoveRange(0, type.DeclaringType.GetGenericArguments().Length);
}
List <TypeReference> genTypeRefs = new List <TypeReference>();
foreach (Type genArg in genArgs)
{
genTypeRefs.Add(genArg.GetTypeReference());
}
if (type.DeclaringType != null)
{
TypeReference outterRef = type.DeclaringType.GetTypeReference();
InnerClassTypeReference innerRef = new InnerClassTypeReference(outterRef, name, genTypeRefs);
innerRef.PointerNestingLevel = pointerNest;
innerRef.RankSpecifier = arrayRanks.ToArray();
return(innerRef.SetStaticType((DebugType)type));
}
else
{
return(new TypeReference(name, pointerNest, arrayRanks.ToArray(), genTypeRefs).SetStaticType((DebugType)type));
}
}
public override object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data)
{
return base.VisitInnerClassTypeReference(innerClassTypeReference, data);
}
void NonArrayTypeName(
#line 1971 "VBNET.ATG"
out TypeReference typeref, bool canBeUnbound) {
#line 1973 "VBNET.ATG"
string name;
typeref = null;
bool isGlobal = false;
if (StartOf(9)) {
if (la.kind == 199) {
lexer.NextToken();
Expect(10);
#line 1978 "VBNET.ATG"
isGlobal = true;
}
QualIdentAndTypeArguments(
#line 1979 "VBNET.ATG"
out typeref, canBeUnbound);
#line 1980 "VBNET.ATG"
typeref.IsGlobal = isGlobal;
while (la.kind == 10) {
lexer.NextToken();
#line 1981 "VBNET.ATG"
TypeReference nestedTypeRef;
QualIdentAndTypeArguments(
#line 1982 "VBNET.ATG"
out nestedTypeRef, canBeUnbound);
#line 1983 "VBNET.ATG"
typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes);
}
} else if (la.kind == 133) {
lexer.NextToken();
#line 1986 "VBNET.ATG"
typeref = new TypeReference("System.Object");
} else if (StartOf(10)) {
PrimitiveTypeName(
#line 1987 "VBNET.ATG"
out name);
#line 1987 "VBNET.ATG"
typeref = new TypeReference(name);
} else SynErr(220);
}
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);
}
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) {
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) {
throw new global::System.NotImplementedException("InnerClassTypeReference");
}
public virtual object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
throw CreateException(innerClassTypeReference);
}
public sealed override object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
this.BeginVisit(innerClassTypeReference);
object result = this.TrackedVisitInnerClassTypeReference(innerClassTypeReference, data);
this.EndVisit(innerClassTypeReference);
return result;
}
void TypeName(
//#line 2296 "cs.ATG"
out TypeReference typeRef, bool canBeUnbound) {
//#line 2297 "cs.ATG"
List<TypeReference> typeArguments = null;
string alias = null;
string qualident;
Location startLocation = la.Location;
if (
//#line 2303 "cs.ATG"
IdentAndDoubleColon()) {
Identifier();
//#line 2304 "cs.ATG"
alias = t.val;
Expect(10);
}
Qualident(
//#line 2307 "cs.ATG"
out qualident);
if (la.kind == 23) {
TypeArgumentList(
//#line 2308 "cs.ATG"
out typeArguments, canBeUnbound);
}
//#line 2310 "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 2319 "cs.ATG"
DotAndIdent()) {
Expect(15);
//#line 2320 "cs.ATG"
typeArguments = null;
Qualident(
//#line 2321 "cs.ATG"
out qualident);
if (la.kind == 23) {
TypeArgumentList(
//#line 2322 "cs.ATG"
out typeArguments, canBeUnbound);
}
//#line 2323 "cs.ATG"
typeRef = new InnerClassTypeReference(typeRef, qualident, typeArguments);
}
//#line 2325 "cs.ATG"
typeRef.StartLocation = startLocation;
}
void NonArrayTypeName(
//#line 2722 "VBNET.ATG"
out TypeReference typeref, bool canBeUnbound) {
//#line 2724 "VBNET.ATG"
string name;
typeref = null;
bool isGlobal = false;
if (StartOf(11)) {
if (la.kind == 130) {
lexer.NextToken();
Expect(26);
//#line 2729 "VBNET.ATG"
isGlobal = true;
}
QualIdentAndTypeArguments(
//#line 2730 "VBNET.ATG"
out typeref, canBeUnbound);
//#line 2731 "VBNET.ATG"
typeref.IsGlobal = isGlobal;
while (la.kind == 26) {
lexer.NextToken();
//#line 2732 "VBNET.ATG"
TypeReference nestedTypeRef;
QualIdentAndTypeArguments(
//#line 2733 "VBNET.ATG"
out nestedTypeRef, canBeUnbound);
//#line 2734 "VBNET.ATG"
typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes);
}
} else if (la.kind == 168) {
lexer.NextToken();
//#line 2737 "VBNET.ATG"
typeref = new TypeReference("System.Object", true);
if (la.kind == 33) {
lexer.NextToken();
//#line 2741 "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(12)) {
PrimitiveTypeName(
//#line 2747 "VBNET.ATG"
out name);
//#line 2747 "VBNET.ATG"
typeref = new TypeReference(name, true);
if (la.kind == 33) {
lexer.NextToken();
//#line 2751 "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(254);
}
public override object VisitInnerClassTypeReference (InnerClassTypeReference node, object data)
{
VisitTypeReference (node, data);
return null;
}
