isGenericParameter() public méthode

Return if this type is a generic parameter (such as V or K) in a generic type (List, Map, or Method). Generic parameters serve as place holders for the parameterization of the generic type. Fantom has a predefined set of generic parameters which are always defined in the sys pod with a one character name.
public isGenericParameter ( ) : bool
Résultat bool
Type Class Documentation
Exemple #1
0
        //////////////////////////////////////////////////////////////////////////
        // Constructor
        //////////////////////////////////////////////////////////////////////////
        public FuncType(Type[] pars, Type ret)
            : base(Sys.FuncType)
        {
            this.m_params = pars;
              this.m_ret    = ret;

              // I am a generic parameter type if any my args or
              // return type are generic parameter types.
              this.m_genericParameterType |= ret.isGenericParameter();
              for (int i=0; i<m_params.Length; ++i)
            this.m_genericParameterType |= m_params[i].isGenericParameter();
        }
Exemple #2
0
        //////////////////////////////////////////////////////////////////////////
        // Constructor
        //////////////////////////////////////////////////////////////////////////

        public FuncType(Type[] pars, Type ret)
            : base(Sys.FuncType)
        {
            this.m_params = pars;
            this.m_ret    = ret;

            // I am a generic parameter type if any my args or
            // return type are generic parameter types.
            this.m_genericParameterType |= ret.isGenericParameter();
            for (int i = 0; i < m_params.Length; ++i)
            {
                this.m_genericParameterType |= m_params[i].isGenericParameter();
            }
        }
Exemple #3
0
        /// <summary>
        /// Parameterize the specified field (reuse if generic
        /// parameterization isn't necessary).
        /// </summary>
        internal Field parameterize(Field f)
        {
            // if not generic, short circuit and reuse original
            Type of = f.type();

            if (!of.isGenericParameter())
            {
                return(f);
            }

            // create new parameterized version
            of = parameterize(of);
            Field pf = new Field(this, f.m_name, f.m_flags, f.m_facets, f.m_lineNum, of);

            pf.m_reflect = f.m_reflect;
            return(pf);
        }
Exemple #4
0
        /// <summary>
        /// Recursively parameterize the pars of a method type.
        /// </summary>
        internal FuncType parameterizeFuncType(FuncType t)
        {
            Type[] pars = new Type[t.m_params.Length];
            for (int i = 0; i < pars.Length; i++)
            {
                Type param = t.m_params[i];
                if (param.isGenericParameter())
                {
                    param = doParameterize(param);
                }
                pars[i] = param;
            }

            Type ret = t.m_ret;

            if (ret.isGenericParameter())
            {
                ret = doParameterize(ret);
            }

            return(new FuncType(pars, ret));
        }
Exemple #5
0
        /// <summary>
        /// Compute if the method signature contains generic parameter types.
        /// </summary>
        private static int toMask(Type parent, Type returns, List pars)
        {
            // we only use generics in Sys
            if (parent.pod() != Sys.m_sysPod)
            {
                return(0);
            }

            int p = returns.isGenericParameter() ? 1 : 0;

            for (int i = 0; i < pars.sz(); ++i)
            {
                p |= ((Param)pars.get(i)).m_type.isGenericParameter() ? 1 : 0;
            }

            int mask = 0;

            if (p != 0)
            {
                mask |= GENERIC;
            }
            return(mask);
        }