C# ComposedType类代码示例

 public override void VisitComposedType(ComposedType composedType)
 {
     // Note: we specifically do not handle this case because the 'base' implementation will eventually
     // call VisitMemberType() or VisitSimpleType() on the ComposedType.BaseType which is all we really
     // care to resolve.
     base.VisitComposedType (composedType);
 }

		public override void VisitComposedType(ComposedType composedType)
		{
			var spec = composedType.ArraySpecifiers.FirstOrDefault();
			if (spec != null)
				ForceSpacesBefore(spec.LBracketToken, policy.SpaceBeforeArrayDeclarationBrackets);

			if (composedType.HasNullableSpecifier)
				ForceSpacesBefore(composedType.NullableSpecifierToken, false);

			if (composedType.PointerRank > 0)
				foreach (var token in composedType.PointerTokens)
					ForceSpacesBefore(token, false);

			base.VisitComposedType(composedType);
		}

			public override object Visit(ComposedCast composedCast)
			{
				var result = new ComposedType();
				result.AddChild(ConvertToType(composedCast.Left), Roles.Type);
				
				var spec = composedCast.Spec;
				while (spec != null) {
					if (spec.IsNullable) {
						result.AddChild(new CSharpTokenNode(Convert(spec.Location), ComposedType.NullableRole), ComposedType.NullableRole);
					} else if (spec.IsPointer) {
						result.AddChild(new CSharpTokenNode(Convert(spec.Location), ComposedType.PointerRole), ComposedType.PointerRole);
					} else {
						var aSpec = new ArraySpecifier();
						aSpec.AddChild(new CSharpTokenNode(Convert(spec.Location), Roles.LBracket), Roles.LBracket);
						var location = LocationsBag.GetLocations(spec);
						if (location != null)
							aSpec.AddChild(new CSharpTokenNode(Convert(spec.Location), Roles.RBracket), Roles.RBracket);
						result.AddChild(aSpec, ComposedType.ArraySpecifierRole);
					}
					spec = spec.Next;
				}
				
				return result;
			}

			AstType ConvertToType(Mono.CSharp.Expression typeName)
			{
				if (typeName == null) // may happen in typeof(Generic<,,,,>)
					return new SimpleType();
				
				var typeExpr = typeName as TypeExpression;
				if (typeExpr != null) {
					return new PrimitiveType(typeExpr.GetSignatureForError(), Convert(typeExpr.Location));
				}
				
				var qam = typeName as QualifiedAliasMember;
				if (qam != null) {
					var loc = LocationsBag.GetLocations(typeName);
					var memberType = new MemberType();
					memberType.Target = new SimpleType(qam.alias, Convert(qam.Location));
					memberType.IsDoubleColon = true;

					if (loc != null && loc.Count > 0)
						memberType.AddChild(new CSharpTokenNode(Convert(loc [0]), Roles.DoubleColon), Roles.DoubleColon);

					memberType.MemberNameToken = Identifier.Create(qam.Name, loc != null ? Convert(loc [1]) : TextLocation.Empty);
					AddTypeArguments(qam, memberType);
					return memberType;
				}
				
				var ma = typeName as MemberAccess;
				if (ma != null) {
					var memberType = new MemberType();
					memberType.AddChild(ConvertToType(ma.LeftExpression), MemberType.TargetRole);
					var loc = LocationsBag.GetLocations(ma);
					if (loc != null)
						memberType.AddChild(new CSharpTokenNode(Convert(loc [0]), Roles.Dot), Roles.Dot);

					memberType.MemberNameToken = Identifier.Create(ma.Name, Convert(ma.Location));
					
					AddTypeArguments(ma, memberType);
					return memberType;
				}
				
				var sn = typeName as SimpleName;
				if (sn != null) {
					var result = new SimpleType(sn.Name, Convert(sn.Location));
					AddTypeArguments(sn, result);
					return result;
				}
				
				var cc = typeName as ComposedCast;
				if (cc != null) {
					var baseType = ConvertToType(cc.Left);
					var result = new ComposedType { BaseType = baseType };
					var ccSpec = cc.Spec;
					while (ccSpec != null) {
						if (ccSpec.IsNullable) {
							result.AddChild(new CSharpTokenNode(Convert(ccSpec.Location), ComposedType.NullableRole), ComposedType.NullableRole);
						} else if (ccSpec.IsPointer) {
							result.AddChild(new CSharpTokenNode(Convert(ccSpec.Location), ComposedType.PointerRole), ComposedType.PointerRole);
						} else {
							var location = LocationsBag.GetLocations(ccSpec);
							var spec = new ArraySpecifier { Dimensions = ccSpec.Dimension };
							spec.AddChild(new CSharpTokenNode(Convert(ccSpec.Location), Roles.LBracket), Roles.LBracket);
							if (location != null)
								spec.AddChild(new CSharpTokenNode(Convert(location [0]), Roles.RBracket), Roles.RBracket);
							
							result.ArraySpecifiers.Add(spec);
						}
						ccSpec = ccSpec.Next;
					}
					return result;
				}
				
				var sce = typeName as SpecialContraintExpr;
				if (sce != null) {
					switch (sce.Constraint) {
						case SpecialConstraint.Class:
							return new PrimitiveType("class", Convert(sce.Location));
						case SpecialConstraint.Struct:
							return new PrimitiveType("struct", Convert(sce.Location));
						case SpecialConstraint.Constructor:
							return new PrimitiveType("new", Convert(sce.Location));
					}
				}
				return new SimpleType("unknown");
			}

			AstType ConvertToType (Mono.CSharp.Expression typeName)
			{
				if (typeName == null) // may happen in typeof(Generic<,,,,>)
					return new SimpleType ();
				
				if (typeName is TypeExpression) {
					var typeExpr = (Mono.CSharp.TypeExpression)typeName;
					return new PrimitiveType (typeExpr.GetSignatureForError (), Convert (typeExpr.Location));
				}
				
				if (typeName is Mono.CSharp.QualifiedAliasMember) {
					var qam = (Mono.CSharp.QualifiedAliasMember)typeName;
					var memberType = new MemberType (); 
					memberType.Target = new SimpleType (qam.alias, Convert (qam.Location));
					memberType.IsDoubleColon = true;
					memberType.MemberName = qam.Name;
					return memberType;
				}
				
				if (typeName is MemberAccess) {
					MemberAccess ma = (MemberAccess)typeName;
					
					var memberType = new MemberType ();
					memberType.AddChild (ConvertToType (ma.LeftExpression), MemberType.TargetRole);
					memberType.AddChild (new CSharpTokenNode (Convert (ma.DotLocation), 1), MemberType.Roles.Dot);
					
					memberType.MemberNameToken = Identifier.Create (ma.Name, Convert (ma.Location));
					
					AddTypeArguments (ma, memberType);
					return memberType;
				}
				
				if (typeName is SimpleName) {
					var sn = (SimpleName)typeName;
					var result = new SimpleType (sn.Name, Convert (sn.Location));
					AddTypeArguments (sn, result);
					return result;
				}
				
				if (typeName is ComposedCast) {
					var cc = (ComposedCast)typeName;
					var baseType = ConvertToType (cc.Left);
					var result = new ComposedType () { BaseType = baseType };
					var ccSpec = cc.Spec;
					while (ccSpec != null) {
						if (ccSpec.IsNullable) {
							result.AddChild (new CSharpTokenNode (Convert (ccSpec.Location), 1), ComposedType.NullableRole);
						} else if (ccSpec.IsPointer) {
							result.AddChild (new CSharpTokenNode (Convert (ccSpec.Location), 1), ComposedType.PointerRole);
						} else {
							var location = LocationsBag.GetLocations (ccSpec);
							var spec = new ArraySpecifier () { Dimensions = ccSpec.Dimension };
							spec.AddChild (new CSharpTokenNode (Convert (ccSpec.Location), 1), FieldDeclaration.Roles.LBracket);
							if (location != null)
								spec.AddChild (new CSharpTokenNode (Convert (location [0]), 1), FieldDeclaration.Roles.RBracket);
							
							result.ArraySpecifiers.Add (spec);
						}
						ccSpec = ccSpec.Next;
					}
					return result;
				}
				
				if (typeName is SpecialContraintExpr) {
					var sce = (SpecialContraintExpr)typeName;
					switch (sce.Constraint) {
					case SpecialConstraint.Class:
						return new PrimitiveType ("class", Convert (sce.Location));
					case SpecialConstraint.Struct:
						return new PrimitiveType ("struct", Convert (sce.Location));
					case SpecialConstraint.Constructor:
						return new PrimitiveType ("new", Convert (sce.Location));
					}
				}
				System.Console.WriteLine ("Error while converting :" + typeName + " - unknown type name");
				System.Console.WriteLine (Environment.StackTrace);
				return new SimpleType ("unknown");
			}

 public virtual void VisitComposedType(ComposedType composedType)
 {
     if (this.ThrowException)
     {
         throw (Exception)this.CreateException(composedType);
     }
 }

		public override void VisitComposedType(ComposedType composedType)
		{
			var spec = composedType.ArraySpecifiers.FirstOrDefault();
			if (spec != null) {
				ForceSpacesBefore(spec.LBracketToken, policy.SpaceBeforeArrayDeclarationBrackets);
			}

			base.VisitComposedType(composedType);
		}

				public override void VisitComposedType (ComposedType composedType)
				{
					base.VisitComposedType (composedType);

					if (!composedType.HasNullableSpecifier)
						return;

					var st = new SimpleType ("Nullable", composedType.BaseType.Clone ());

					composedType.ReplaceWith (st);
				}

 public abstract StringBuilder VisitComposedType(ComposedType composedType, int data);

 public override void VisitComposedType(ComposedType composedType)
 {
     new TypeBlock(this, composedType).Emit();
 }

 public override StringBuilder VisitComposedType(ComposedType composedType, int data)
 {
     throw new NotImplementedException();
 }

		public virtual void VisitComposedType(ComposedType composedType)
		{
			StartNode(composedType);
			composedType.BaseType.AcceptVisitor(this);
			if (composedType.HasNullableSpecifier) {
				WriteToken(ComposedType.NullableRole, BoxedTextColor.Operator);
			}
			int count = 0;
			for (int i = 0; i < composedType.PointerRank; i++) {
				if (count-- <= 0) {
					cancellationToken.ThrowIfCancellationRequested();
					count = CANCEL_CHECK_LOOP_COUNT;
				}
				WriteToken(ComposedType.PointerRole, BoxedTextColor.Operator);
			}
			count = 0;
			foreach (var node in composedType.ArraySpecifiers) {
				if (count-- <= 0) {
					cancellationToken.ThrowIfCancellationRequested();
					count = CANCEL_CHECK_LOOP_COUNT;
				}
				node.AcceptVisitor(this);
			}
			EndNode(composedType);
		}

 public void VisitComposedType(ComposedType composedType)
 {
     JsonObject jsonComposedType = new JsonObject();
     jsonComposedType.Comment = "VisitComposedType";
     composedType.BaseType.AcceptVisitor(this);
     jsonComposedType.AddJsonValue("basetype", Pop());
     if (composedType.HasNullableSpecifier)
     {
         jsonComposedType.AddJsonValue("nullable-specifier", ComposedType.NullableRole.Token);
     }
     jsonComposedType.AddJsonValue("pointerrank", composedType.PointerRank);
     JsonArray arraySpecifier = new JsonArray();
     foreach (var node in composedType.ArraySpecifiers)
     {
         node.AcceptVisitor(this);
         arraySpecifier.AddJsonValue(Pop());
     }
     Push(jsonComposedType);
 }

			public override void VisitMethodDeclaration (MethodDeclaration methodDeclaration)
			{
				base.VisitMethodDeclaration (methodDeclaration);

				var hasRefs = methodDeclaration.Parameters.Any (IsRefParam);

				if (!hasRefs)
					return;

				var sub = new Substitute ();

				foreach (var p in methodDeclaration.Parameters.Where (IsRefParam).ToList ()) {

					var pty =  ((ComposedType)p.Type).BaseType;


					var access = new IndexerExpression (new IdentifierExpression (p.Name), new PrimitiveExpression (0));
					var ptd = GetTypeDef (pty);
					if (ptd != null)
						access.AddAnnotation (ptd);
					sub.Subs [p.Name] = access;
					p.ParameterModifier = ParameterModifier.None;
					var c = new ComposedType {
						BaseType = p.Type.Clone (),
					};
					c.ArraySpecifiers.Add (new ArraySpecifier (1));
					p.Type = c;
				}

				methodDeclaration.Body.AcceptVisitor (sub);
			}

		public virtual void VisitComposedType (ComposedType composedType)
		{
			VisitChildren (composedType);
		}