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; }