Exemple #1
0
        internal static TypeRef FromGenericQualifiedName(Span span, GenericQualifiedName qname)
        {
            var tref = new ClassTypeRef(span, qname.QualifiedName);

            if (qname.IsGeneric)
            {
                return(new GenericTypeRef(span, tref, qname.GenericParams.Select(p => FromObject(Span.Invalid, p)).ToList()));
            }
            else
            {
                return(tref);
            }
        }
Exemple #2
0
 internal PseudoClassConstUse(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, Types type, Text.Span namePosition)
     : this(span, ClassTypeRef.FromGenericQualifiedName(classNamePosition, className), type, namePosition)
 {
 }
Exemple #3
0
 public override void VisitClassTypeRef(ClassTypeRef x)
 {
     _results.Push(new GenericQualifiedName(x.ClassName));
 }
Exemple #4
0
        /// <summary>
        /// Creates direct type reference from a string.
        /// </summary>
        /// <param name="span">Position of the name.</param>
        /// <param name="name">Input string, primitive type name or a class name.</param>
        /// <param name="naming">Optional the naming context. The name will be translated.</param>
        /// <returns>Type reference. Cannot be <c>null</c>.</returns>
        public static TypeRef FromString(Span span, string name, NamingContext naming = null)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentException(nameof(name));
            }

            // multiple types
            var sepindex = name.IndexOf(PHPDocBlock.TypeVarDescTag.TypeNamesSeparator);

            if (sepindex >= 0)
            {
                var names = name.Split(new char[] { PHPDocBlock.TypeVarDescTag.TypeNamesSeparator });
                Debug.Assert(names.Length > 1);
                var trefs  = new TypeRef[names.Length];
                int offset = 0;
                for (int i = 0; i < names.Length; i++)
                {
                    var str = names[i];
                    trefs[i] = FromString(new Span(span.Start + offset, str.Length), str, naming);
                    offset  += str.Length + 1; // + separator
                }
                return(new MultipleTypeRef(span, trefs));
            }

            // nullable
            if (name[0] == '?')
            {
                return(new NullableTypeRef(span, FromString(new Span(span.Start + 1, span.Length - 1), name.Substring(1), naming)));
            }

            //
            var qname = Syntax.QualifiedName.Parse(name, false);

            // primitive types
            PrimitiveTypeRef.PrimitiveType primitive;
            if (qname.IsSimpleName && Enum.TryParse(qname.Name.Value, true, out primitive))
            {
                return(new PrimitiveTypeRef(span, primitive));
            }

            // reserved type names
            ReservedTypeRef.ReservedType rtype;
            if (qname.IsSimpleName && ReservedTypeRef.ReservedTypes.TryGetValue(qname.Name, out rtype))
            {
                return(new ReservedTypeRef(span, rtype));
            }

            // direct types
            TypeRef result = new ClassTypeRef(span, qname);

            // apply naming context
            QualifiedName translated;

            if (Syntax.QualifiedName.TryTranslateAlias(qname, naming, out translated))
            {
                result = new TranslatedTypeRef(span, translated, result);
            }

            //
            return(result);
        }