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 object VisitComposedType(ComposedType composedType, object data)
{
var spec = composedType.ArraySpecifiers.FirstOrDefault();
if (spec != null)
{
ForceSpacesBefore(spec.LBracketToken, policy.SpacesBeforeArrayDeclarationBrackets);
}
return(base.VisitComposedType(composedType, data));
}
public override bool VisitComposedType(ComposedType composedType)
{
if (composedType.PointerRank > 0)
{
return(true);
}
else
{
return(base.VisitComposedType(composedType));
}
}
public void NullableIsExpressionInBinaryOperatorExpression()
{
BinaryOperatorExpression boe;
boe = ParseUtilCSharp.ParseExpression <BinaryOperatorExpression>("o is int? == true");
IsExpression ce = (IsExpression)boe.Left;
ComposedType type = (ComposedType)ce.Type;
Assert.IsTrue(type.HasNullableSpecifier);
Assert.AreEqual("int", ((PrimitiveType)type.BaseType).Keyword);
Assert.IsTrue(ce.Expression is IdentifierExpression);
}
public override StringBuilder VisitComposedType(ComposedType composedType, int data)
{
var result = new StringBuilder();
result.Append(composedType.BaseType.AcceptVisitor(this, data));
foreach (var spec in composedType.ArraySpecifiers)
{
result.Append(spec);
}
return(result);
}
internal static Type GetActualType(this AstType astType)
{
ComposedType composedType = astType as ComposedType;
if (composedType != null)
{
return(composedType.GetActualType());
}
PrimitiveType primitiveType = astType as PrimitiveType;
if (primitiveType != null)
{
return(primitiveType.GetActualType());
}
MemberType memberType = astType as MemberType;
if (memberType != null)
{
return(memberType.GetActualType());
}
var simpleType = astType as SimpleType;
if (simpleType != null)
{
return(simpleType.GetActualType());
}
if (astType.HasAnnotations())
{
var typeReference = astType.Annotation <TypeReference>();
if (typeReference != null)
{
return(typeReference.GetActualType());
}
var typeDefinition = astType.Annotation <TypeDefinition>();
if (typeDefinition != null)
{
return(typeDefinition.GetActualType());
}
}
return(null);
}
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 void DereferenceAfterCast()
{
UnaryOperatorExpression uoe = ParseUtilCSharp.ParseExpression <UnaryOperatorExpression>("*((SomeType*) &w)");
Assert.AreEqual(UnaryOperatorType.Dereference, uoe.Operator);
ParenthesizedExpression pe = (ParenthesizedExpression)uoe.Expression;
CastExpression ce = (CastExpression)pe.Expression;
ComposedType type = (ComposedType)ce.Type;
Assert.AreEqual("SomeType", ((SimpleType)type.BaseType).Identifier);
Assert.AreEqual(1, type.PointerRank);
UnaryOperatorExpression adrOf = (UnaryOperatorExpression)ce.Expression;
Assert.AreEqual(UnaryOperatorType.AddressOf, adrOf.Operator);
}
public Expression ConvertConstantValue(ResolveResult rr)
{
if (rr == null)
{
throw new ArgumentNullException("rr");
}
if (rr is TypeOfResolveResult)
{
return(new TypeOfExpression(ConvertType(((TypeOfResolveResult)rr).Type)));
}
else if (rr is ArrayCreateResolveResult)
{
ArrayCreateResolveResult acrr = (ArrayCreateResolveResult)rr;
ArrayCreateExpression ace = new ArrayCreateExpression();
ace.Type = ConvertType(acrr.Type);
ComposedType composedType = ace.Type as ComposedType;
if (composedType != null)
{
composedType.ArraySpecifiers.MoveTo(ace.AdditionalArraySpecifiers);
if (!composedType.HasNullableSpecifier && composedType.PointerRank == 0)
{
ace.Type = composedType.BaseType;
}
}
if (acrr.SizeArguments != null && acrr.InitializerElements == null)
{
ace.AdditionalArraySpecifiers.FirstOrNullObject().Remove();
ace.Arguments.AddRange(acrr.SizeArguments.Select(ConvertConstantValue));
}
if (acrr.InitializerElements != null)
{
ArrayInitializerExpression initializer = new ArrayInitializerExpression();
initializer.Elements.AddRange(acrr.InitializerElements.Select(ConvertConstantValue));
ace.Initializer = initializer;
}
return(ace);
}
else if (rr.IsCompileTimeConstant)
{
return(ConvertConstantValue(rr.Type, rr.ConstantValue));
}
else
{
return(new EmptyExpression());
}
}
public Expression ConvertConstantValue(ResolveResult rr)
{
if (rr == null)
throw new ArgumentNullException("rr");
if (rr is ConversionResolveResult) {
// unpack ConversionResolveResult if necessary
// (e.g. a boxing conversion or string->object reference conversion)
rr = ((ConversionResolveResult)rr).Input;
}
if (rr is TypeOfResolveResult) {
var expr = new TypeOfExpression(ConvertType(((TypeOfResolveResult)rr).ReferencedType));
if (AddResolveResultAnnotations)
expr.AddAnnotation(rr);
return expr;
} else if (rr is ArrayCreateResolveResult) {
ArrayCreateResolveResult acrr = (ArrayCreateResolveResult)rr;
ArrayCreateExpression ace = new ArrayCreateExpression();
ace.Type = ConvertType(acrr.Type);
ComposedType composedType = ace.Type as ComposedType;
if (composedType != null) {
composedType.ArraySpecifiers.MoveTo(ace.AdditionalArraySpecifiers);
if (!composedType.HasNullableSpecifier && composedType.PointerRank == 0)
ace.Type = composedType.BaseType;
}
if (acrr.SizeArguments != null && acrr.InitializerElements == null) {
ace.AdditionalArraySpecifiers.FirstOrNullObject().Remove();
ace.Arguments.AddRange(acrr.SizeArguments.Select(ConvertConstantValue));
}
if (acrr.InitializerElements != null) {
ArrayInitializerExpression initializer = new ArrayInitializerExpression();
initializer.Elements.AddRange(acrr.InitializerElements.Select(ConvertConstantValue));
ace.Initializer = initializer;
}
if (AddResolveResultAnnotations)
ace.AddAnnotation(rr);
return ace;
} else if (rr.IsCompileTimeConstant) {
return ConvertConstantValue(rr.Type, rr.ConstantValue);
} else {
return new ErrorExpression();
}
}
internal static Type GetActualType(this ComposedType composedType)
{
Type type = GetActualType(composedType.BaseType);
if (!composedType.HasNullableSpecifier)
{
composedType.ArraySpecifiers
.Reverse()
.ForEach(s => {
int dimensions = s.Dimensions;
type = dimensions > 1 ? type.MakeArrayType(dimensions) : type.MakeArrayType();
});
}
else
{
type = typeof(Nullable <>).MakeGenericType(type);
}
return(type);
}
public override bool DoMatch(INode other, Match match)
{
ComposedType ct = other as ComposedType;
AstType o;
if (ct != null && !ct.HasNullableSpecifier && ct.PointerRank == 0 && !ct.ArraySpecifiers.Any())
{
// Special case: ILSpy sometimes produces a ComposedType but then removed all array specifiers
// from it. In that case, we need to look at the base type for the annotations.
o = ct.BaseType;
}
else
{
o = other as AstType;
if (o == null)
{
return(false);
}
}
ITypeDefOrRef tr = o.Annotation <ITypeDefOrRef>();
return(tr.Compare(ns, name));
}
public override bool DoMatch(INode other, Match match)
{
ComposedType ct = other as ComposedType;
AstType o;
if (ct != null && !ct.HasRefSpecifier && !ct.HasNullableSpecifier && ct.PointerRank == 0 && !ct.ArraySpecifiers.Any())
{
// Special case: ILSpy sometimes produces a ComposedType but then removed all array specifiers
// from it. In that case, we need to look at the base type for the annotations.
o = ct.BaseType;
}
else
{
o = other as AstType;
if (o == null)
{
return(false);
}
}
var trr = o.GetResolveResult() as TypeResolveResult;
return(trr != null && trr.Type.Namespace == ns && trr.Type.Name == name);
}
static string Resolve(this ComposedType type, EvaluationContext ctx, List <object> args)
{
string name;
if (type.HasNullableSpecifier)
{
args.Insert(0, type.BaseType.Resolve(ctx));
name = "System.Nullable`1";
}
else
{
name = type.BaseType.Resolve(ctx, args);
}
if (type.PointerRank > 0)
{
name += new string ('*', type.PointerRank);
}
if (type.ArraySpecifiers.Count > 0)
{
foreach (var spec in type.ArraySpecifiers)
{
if (spec.Dimensions > 1)
{
name += "[" + new string (',', spec.Dimensions - 1) + "]";
}
else
{
name += "[]";
}
}
}
return(name);
}
public object VisitComposedType(ComposedType composedType, object data)
{
throw new NotImplementedException();
}
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");
}
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");
}
public override void VisitComposedType(ComposedType composedType)
{
var spec = composedType.ArraySpecifiers.FirstOrDefault();
if (spec != null) {
ForceSpacesBefore(spec.LBracketToken, policy.SpaceBeforeArrayDeclarationBrackets);
}
base.VisitComposedType(composedType);
}
public override StringBuilder VisitComposedType(ComposedType composedType, int data)
{
throw new NotImplementedException();
}
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 virtual Node VisitComposedType(ComposedType composedType)
{
throw new System.NotImplementedException();
}
public override StringBuilder VisitComposedType(ComposedType composedType, int data)
{
throw new NotImplementedException();
}
public virtual S VisitComposedType(ComposedType composedType, T data)
{
return(VisitChildren(composedType, data));
}
public abstract StringBuilder VisitComposedType(ComposedType composedType, int data);
public void VisitComposedType(ComposedType composedType)
{
throw new NotImplementedException();
}
public Node VisitComposedType(ComposedType composedType)
{
return(CreateDummy(composedType));
}
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
{
ComposedType o = other as ComposedType;
return(o != null);
}
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 override void VisitComposedType(ComposedType composedType)
{
this.CheckType(composedType);
base.VisitComposedType(composedType);
}
public JNode VisitComposedType(ComposedType node)
{
throw new NotImplementedException();
}
public RedILNode VisitComposedType(ComposedType composedType, State data)
{
throw new System.NotImplementedException();
}
public override AstNode VisitComposedType(ComposedType composedType, ICecilArgumentsResolver argumentsResolver)
{
composedType.BaseType.AcceptVisitor(this, argumentsResolver);
return(composedType);
}
public override void VisitComposedType(ComposedType syntax)
{
_underlyingVisitor.VisitComposedType(syntax);
}
public virtual void VisitComposedType (ComposedType composedType)
{
VisitChildren (composedType);
}
public override void VisitComposedType(ComposedType composedType)
{
new TypeBlock(this, composedType).Emit();
}
public void TryGenerateCode()
{
AstNode root = GetRoot();
foreach (var item in root.Children)
{
Debug.Log(item);
}
if (root.Descendants.OfType <UsingDeclaration>().Where(x => x.Namespace == "System").Count() == 0)
{
root.AddChild <AstNode>(new UsingDeclaration("System"), Roles.Root);
}
if (root.Descendants.OfType <UsingDeclaration>().Where(x => x.Namespace == "UnityEngine").Count() == 0)
{
root.AddChild <AstNode>(new UsingDeclaration("UnityEngine"), Roles.Root);
}
TypeDeclaration classNode = null;
if (root.Descendants.OfType <TypeDeclaration>().Where(x => x.Name == "DemoClass").Count() != 0)
{
classNode = root.Descendants.OfType <TypeDeclaration>().Where(x => x.Name == "DemoClass").First();
}
else
{
classNode = new TypeDeclaration();
classNode.Name = "DemoClass";
classNode.Modifiers = Modifiers.Public;
var comment = new Comment("<summary>", CommentType.Documentation);
root.AddChild(comment, Roles.Comment);
comment = new Comment("代码说明信息", CommentType.Documentation);
root.AddChild(comment, Roles.Comment);
comment = new Comment("<summary>", CommentType.Documentation);
root.AddChild(comment, Roles.Comment);
root.AddChild(classNode, Roles.TypeMemberRole);
}
if (classNode.Descendants.OfType <FieldDeclaration>().Where(x => x.Variables.Where(y => y.Name == "DemoField").Count() > 0).Count() == 0)
{
var field = new FieldDeclaration();
field.Modifiers = Modifiers.Public;
field.ReturnType = new BridgeUI.NRefactory.CSharp.PrimitiveType("int");
field.Variables.Add(new VariableInitializer("DemoField", new IdentifierExpression("0")));
classNode.AddChild(field, Roles.TypeMemberRole);
}
if (classNode.Descendants.OfType <ConstructorDeclaration>().Where(x => x.Name == "DemoClass").Count() == 0)
{
var constractNode = new ConstructorDeclaration();
constractNode.Modifiers = Modifiers.Public;
constractNode.Name = "DemoClass";
var statement = new BlockStatement();
statement.Add(new AssignmentExpression(new IdentifierExpression("DemoField"), new PrimitiveExpression(1)));
constractNode.Body = statement;
classNode.AddChild(constractNode, Roles.TypeMemberRole);
}
if (classNode.Descendants.OfType <MethodDeclaration>().Where(x => x.Name == "DemoFunction").Count() == 0)
{
var mainFuncNode = new MethodDeclaration();
mainFuncNode.Modifiers = Modifiers.Public;
mainFuncNode.Name = "DemoFunction";
mainFuncNode.ReturnType = new BridgeUI.NRefactory.CSharp.PrimitiveType("void");
var parameter1 = new ParameterDeclaration();
parameter1.Type = new BridgeUI.NRefactory.CSharp.PrimitiveType("int");
parameter1.Name = "arg1";
mainFuncNode.Parameters.Add(parameter1);
var statement = new BlockStatement();
statement.Add(new InvocationExpression(new MemberReferenceExpression(new IdentifierExpression("Debug"), "Log", new AstType[0]), new PrimitiveExpression("Hellow World")));
mainFuncNode.Body = statement;
var parameter2 = new ParameterDeclaration();
//parameter2.Type = new BridgeUI.NRefactory.CSharp.PrimitiveType("int[]");
var type = new ComposedType();
type.ArraySpecifiers.Add(new ArraySpecifier());
type.BaseType = new BridgeUI.NRefactory.CSharp.PrimitiveType("int");
type.HasNullableSpecifier = true;
parameter2.Type = type;
parameter2.Name = "arg2";
mainFuncNode.Parameters.Add(parameter2);
classNode.AddChild(mainFuncNode, Roles.TypeMemberRole);
}
Debug.Log(root.ToString());
SaveToAssetFolder(root.ToString());
}
public virtual void VisitComposedType(ComposedType composedType)
{
if (this.ThrowException)
{
throw (Exception)this.CreateException(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 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);
}
AstType ConvertToType (Mono.CSharp.Expression typeName)
{
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;
return new SimpleType (qam.Name, Convert (qam.Location));
}
if (typeName is MemberAccess) {
MemberAccess ma = (MemberAccess)typeName;
var memberType = new MemberType ();
memberType.AddChild (ConvertToType (ma.LeftExpression), MemberType.TargetRole);
memberType.MemberName = ma.Name;
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 };
if (cc.Spec.IsNullable) {
result.HasNullableSpecifier = true;
} else if (cc.Spec.IsPointer) {
result.PointerRank++;
} else {
var location = LocationsBag.GetLocations (cc.Spec);
var spec = new ArraySpecifier () { Dimensions = cc.Spec.Dimension - 1 };
spec.AddChild (new CSharpTokenNode (Convert (cc.Spec.Location), 1), FieldDeclaration.Roles.LBracket);
if (location != null)
spec.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FieldDeclaration.Roles.RBracket);
result.ArraySpecifiers.Add(spec);
}
return result;
}
System.Console.WriteLine ("Error while converting :" + typeName + " - unknown type name");
return new SimpleType ("unknown");
}
/// <summary>
/// Translates a composed data type, e.g. "float4".
/// </summary>
/// <remarks>
/// Exact purpose is unknown. This has something to do with arrays.
/// </remarks>
public override StringBuilder VisitComposedType(ComposedType composedType)
{
return(composedType.BaseType.AcceptVisitor(this));
}
/// <inheritdoc/>
public virtual void VisitComposedType(ComposedType syntax)
{
VisitNode(syntax);
}
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;
}
public UnifiedElement VisitComposedType(
ComposedType composedType, object data)
{
throw new NotImplementedException("ComposedType");
}
public void VisitComposedType(ComposedType composedType)
{
StartNode(composedType);
composedType.BaseType.AcceptVisitor(this);
if (composedType.HasNullableSpecifier) {
WriteToken(ComposedType.NullableRole);
}
for (int i = 0; i < composedType.PointerRank; i++) {
WriteToken(ComposedType.PointerRole);
}
foreach (var node in composedType.ArraySpecifiers) {
node.AcceptVisitor(this);
}
EndNode(composedType);
}
public override void VisitComposedType(ComposedType composedType)
{
new TypeBlock(this, composedType).Emit();
}
public abstract StringBuilder VisitComposedType(ComposedType composedType, int data);
public void VisitComposedType(ComposedType node)
{
VisitChildren(node);
}
