Beispiel #1
0
        public XmlElement Visit(OrdinarySignaturePartParseNode osppn)
        {
            var el = makeNode(osppn, "ordinary-signature-part");

            addProperty(el, "name", osppn.Name);
            addProperty(el, "final", osppn.Final);
            addProperty(el, "genericparameters", osppn.GenericParameters);
            addProperty(el, "parameters", osppn.Parameters);
            return(el);
        }
Beispiel #2
0
 /// <inheritdoc/>
 public virtual ParseNode Visit(OrdinarySignaturePartParseNode osppn)
 {
     foreach (var p in osppn.Parameters)
     {
         p.Visit(this);
     }
     foreach (var p in osppn.GenericParameters)
     {
         p.Visit(this);
     }
     return(osppn);
 }
Beispiel #3
0
        /// <inheritdoc />
        public Node Visit(TypeStatementParseNode tspn)
        {
            var meth = new MethodDeclarationParseNode(tspn.Token);
            var spn  = new SignatureParseNode(tspn.Token);
            var spp  = new OrdinarySignaturePartParseNode((IdentifierParseNode)tspn.BaseName);

            spp.GenericParameters = tspn.GenericParameters;
            spn.AddPart(spp);
            meth.Signature = spn;
            var tpn = tspn.Body as InterfaceParseNode;

            if (tpn != null)
            {
                tpn.Name = ((IdentifierParseNode)tspn.BaseName).Name;
            }
            meth.Body.Add(tspn.Body);
            return(meth.Visit(this));
        }
Beispiel #4
0
        /// <inheritdoc />
        public Node Visit(OrdinarySignaturePartParseNode osppn)
        {
            var parameters = new List <Node>();

            foreach (var p in osppn.Parameters)
            {
                // f
                var id    = p as IdentifierParseNode;
                var tppn  = p as TypedParameterParseNode;
                var vappn = p as VarArgsParameterParseNode;
                if (id != null)
                {
                    parameters.Add(new ParameterNode(id.Token, id));
                }
                else if (tppn != null)
                {
                    parameters.Add(new ParameterNode(tppn.Token,
                                                     tppn.Name as IdentifierParseNode,
                                                     tppn.Type.Visit(this)));
                }
                else if (vappn != null)
                {
                    // Inside could be either an identifier or a
                    // TypedParameterParseNode - check for both.
                    var inIPN  = vappn.Name as IdentifierParseNode;
                    var inTPPN = vappn.Name as TypedParameterParseNode;
                    if (inIPN != null)
                    {
                        parameters.Add(new ParameterNode(inIPN.Token,
                                                         inIPN,
                                                         true // Variadic
                                                         ));
                    }
                    else if (inTPPN != null)
                    {
                        parameters.Add(new ParameterNode(inTPPN.Token,
                                                         inTPPN.Name as IdentifierParseNode,
                                                         true, // Variadic
                                                         inTPPN.Type.Visit(this)
                                                         ));
                    }
                }
                else
                {
                    throw new Exception("unimplemented - unusual parameters");
                }
            }
            var generics = new List <Node>();

            foreach (var p in osppn.GenericParameters)
            {
                var id = p as IdentifierParseNode;
                if (id != null)
                {
                    generics.Add(new ParameterNode(id.Token, id));
                }
                else
                {
                    throw new Exception("unimplemented - bad generic parameters");
                }
            }
            if (osppn.Name.StartsWith("circumfix", StringComparison.Ordinal))
            {
                return(new OrdinarySignaturePartNode(osppn.Token, osppn,
                                                     parameters, generics, false));
            }
            return(new OrdinarySignaturePartNode(osppn.Token, osppn,
                                                 parameters, generics));
        }