private static (TypeSpec Type, string Assembly) HandlePointer(PointerTypeSpec type, string assemblyName, Func <QualifiedType, QualifiedType> replaceTypeName)
        {
            var element = ApplyInner(type.ElementType, assemblyName, replaceTypeName);

            if (ReferenceEquals(element.Type, type.ElementType))
            {
                return(type, element.Assembly);
            }

            return(new PointerTypeSpec(element.Type), element.Assembly);
        }
Ejemplo n.º 2
0
        private static TypeSpec ParseInternal(ref ReadOnlySpan <char> input)
        {
            TypeSpec result;
            char     c;
            Reader   s = default;

            s.Input = input;

            // Read namespace and class name, including generic arity, which is a part of the class name.
            NamedTypeSpec named = null;

            while (true)
            {
                var typeName = ParseTypeName(ref s);
                named = new NamedTypeSpec(named, typeName.ToString(), s.TotalGenericArity);

                if (s.TryPeek(out c) && c == NestedTypeIndicator)
                {
                    // Consume the nested type indicator, then loop to parse the nested type.
                    s.ConsumeCharacter(NestedTypeIndicator);
                    continue;
                }

                break;
            }

            // Parse generic type parameters
            if (s.TotalGenericArity > 0 && s.TryPeek(out c) && c == ArrayStartIndicator)
            {
                s.ConsumeCharacter(ArrayStartIndicator);

                var arguments = new TypeSpec[s.TotalGenericArity];
                for (var i = 0; i < s.TotalGenericArity; i++)
                {
                    if (i > 0)
                    {
                        s.ConsumeCharacter(ParameterSeparator);
                    }

                    // Parse the argument type
                    s.ConsumeCharacter(ArrayStartIndicator);
                    var remaining = s.Remaining;
                    arguments[i] = ParseInternal(ref remaining);
                    var consumed = s.Remaining.Length - remaining.Length;
                    s.Consume(consumed);
                    s.ConsumeCharacter(ArrayEndIndicator);
                }

                s.ConsumeCharacter(ArrayEndIndicator);
                result = new ConstructedGenericTypeSpec(named, arguments);
            }
            else
            {
                // This is not a constructed generic type
                result = named;
            }

            // Parse modifiers
            bool hadModifier;

            do
            {
                hadModifier = false;

                if (!s.TryPeek(out c))
                {
                    break;
                }

                switch (c)
                {
                case ArrayStartIndicator:
                    var dimensions = ParseArraySpecifier(ref s);
                    result      = new ArrayTypeSpec(result, dimensions);
                    hadModifier = true;
                    break;

                case PointerIndicator:
                    result = new PointerTypeSpec(result);
                    s.ConsumeCharacter(PointerIndicator);
                    hadModifier = true;
                    break;

                case ReferenceIndicator:
                    result = new ReferenceTypeSpec(result);
                    s.ConsumeCharacter(ReferenceIndicator);
                    hadModifier = true;
                    break;
                }
            } while (hadModifier);

            // Extract the assembly, if specified.
            if (s.TryPeek(out c) && c == AssemblyIndicator)
            {
                s.ConsumeCharacter(AssemblyIndicator);
                var assembly = ExtractAssemblySpec(ref s);
                result = new AssemblyQualifiedTypeSpec(result, assembly.ToString());
            }

            input = s.Remaining;
            return(result);
        }