Esempio n. 1
0
        public override TypeNode VisitTypeReference(TypeNode type)
        {
            if (type == null)
            {
                return(null);
            }
            Class cl = type as Class;

            if (cl != null)
            {
                this.VisitTypeReference(cl.BaseClass);
            }
            if (this.MembersToFind[type.UniqueKey] != null)
            {
                this.FoundMembers[type.UniqueKey] = type;
                if (!this.insideMethodBody)
                {
                    this.AllReferencesAreConfinedToMethodBodies = false;
                }
                return(type);
            }
            switch (type.NodeType)
            {
            case NodeType.ArrayType:
                ArrayType arrType = (ArrayType)type;
                this.VisitTypeReference(arrType.ElementType);
                return(type);

            case NodeType.DelegateNode: {
                FunctionType ftype = type as FunctionType;
                if (ftype == null)
                {
                    goto default;
                }
                this.VisitTypeReference(ftype.ReturnType);
                this.VisitParameterList(ftype.Parameters);
                return(type);
            }

            case NodeType.Pointer:
                Pointer pType = (Pointer)type;
                this.VisitTypeReference(pType.ElementType);
                return(type);

            case NodeType.Reference:
                Reference rType = (Reference)type;
                this.VisitTypeReference(rType.ElementType);
                return(type);

            case NodeType.TupleType: {
                TupleType  tType   = (TupleType)type;
                MemberList members = tType.Members;
                int        n       = members == null ? 0 : members.Count;
                for (int i = 0; i < n; i++)
                {
                    Field f = members[i] as Field;
                    if (f == null)
                    {
                        continue;
                    }
                    this.VisitTypeReference(f.Type);
                }
                return(type);
            }

            case NodeType.TypeIntersection:
                TypeIntersection tIntersect = (TypeIntersection)type;
                this.VisitTypeReferenceList(tIntersect.Types);
                return(type);

            case NodeType.TypeUnion:
                TypeUnion tUnion = (TypeUnion)type;
                this.VisitTypeReferenceList(tUnion.Types);
                return(type);

            case NodeType.ArrayTypeExpression:
                ArrayTypeExpression aExpr = (ArrayTypeExpression)type;
                this.VisitTypeReference(aExpr.ElementType);
                return(type);

            case NodeType.BoxedTypeExpression:
                BoxedTypeExpression bExpr = (BoxedTypeExpression)type;
                this.VisitTypeReference(bExpr.ElementType);
                return(type);

            case NodeType.ClassExpression:
                ClassExpression cExpr = (ClassExpression)type;
                this.VisitExpression(cExpr.Expression);
                this.VisitTypeReferenceList(cExpr.TemplateArguments);
                return(type);

            case NodeType.ClassParameter:
            case NodeType.TypeParameter:
                return(type);

            case NodeType.ConstrainedType:
                ConstrainedType conType = (ConstrainedType)type;
                this.VisitTypeReference(conType.UnderlyingType);
                this.VisitExpression(conType.Constraint);
                return(type);

            case NodeType.FlexArrayTypeExpression:
                FlexArrayTypeExpression flExpr = (FlexArrayTypeExpression)type;
                this.VisitTypeReference(flExpr.ElementType);
                return(type);

            case NodeType.FunctionTypeExpression:
                FunctionTypeExpression ftExpr = (FunctionTypeExpression)type;
                this.VisitParameterList(ftExpr.Parameters);
                this.VisitTypeReference(ftExpr.ReturnType);
                return(type);

            case NodeType.InvariantTypeExpression:
                InvariantTypeExpression invExpr = (InvariantTypeExpression)type;
                this.VisitTypeReference(invExpr.ElementType);
                return(type);

            case NodeType.InterfaceExpression:
                InterfaceExpression iExpr = (InterfaceExpression)type;
                this.VisitExpression(iExpr.Expression);
                this.VisitTypeReferenceList(iExpr.TemplateArguments);
                return(type);

            case NodeType.NonEmptyStreamTypeExpression:
                NonEmptyStreamTypeExpression neExpr = (NonEmptyStreamTypeExpression)type;
                this.VisitTypeReference(neExpr.ElementType);
                return(type);

            case NodeType.NonNullTypeExpression:
                NonNullTypeExpression nnExpr = (NonNullTypeExpression)type;
                this.VisitTypeReference(nnExpr.ElementType);
                return(type);

            case NodeType.NonNullableTypeExpression:
                NonNullableTypeExpression nbExpr = (NonNullableTypeExpression)type;
                this.VisitTypeReference(nbExpr.ElementType);
                return(type);

            case NodeType.NullableTypeExpression:
                NullableTypeExpression nuExpr = (NullableTypeExpression)type;
                this.VisitTypeReference(nuExpr.ElementType);
                return(type);

            case NodeType.OptionalModifier:
            case NodeType.RequiredModifier:
                TypeModifier modType = (TypeModifier)type;
                this.VisitTypeReference(modType.ModifiedType);
                this.VisitTypeReference(modType.Modifier);
                return(type);

            case NodeType.PointerTypeExpression:
                PointerTypeExpression pExpr = (PointerTypeExpression)type;
                this.VisitTypeReference(pExpr.ElementType);
                return(type);

            case NodeType.ReferenceTypeExpression:
                ReferenceTypeExpression rExpr = (ReferenceTypeExpression)type;
                this.VisitTypeReference(rExpr.ElementType);
                return(type);

            case NodeType.StreamTypeExpression:
                StreamTypeExpression sExpr = (StreamTypeExpression)type;
                this.VisitTypeReference(sExpr.ElementType);
                return(type);

            case NodeType.TupleTypeExpression:
                TupleTypeExpression tuExpr = (TupleTypeExpression)type;
                this.VisitFieldList(tuExpr.Domains);
                return(type);

            case NodeType.TypeExpression:
                TypeExpression tExpr = (TypeExpression)type;
                this.VisitExpression(tExpr.Expression);
                this.VisitTypeReferenceList(tExpr.TemplateArguments);
                return(type);

            case NodeType.TypeIntersectionExpression:
                TypeIntersectionExpression tiExpr = (TypeIntersectionExpression)type;
                this.VisitTypeReferenceList(tiExpr.Types);
                return(type);

            case NodeType.TypeUnionExpression:
                TypeUnionExpression tyuExpr = (TypeUnionExpression)type;
                this.VisitTypeReferenceList(tyuExpr.Types);
                return(type);

            default:
                if (type.Template != null && type.TemplateArguments != null)
                {
                    this.VisitTypeReference(type.Template);
                    this.VisitTypeReferenceList(type.TemplateArguments);
                }
                return(type);
            }
        }
Esempio n. 2
0
        public override TypeNode VisitTypeReference(TypeNode type)
        { //TODO: break up this method
            if (type == null)
            {
                return(null);
            }
            TypeNodeList pars = this.pars;
            TypeNodeList args = this.args;

            switch (type.NodeType)
            {
            case NodeType.ArrayType:
                ArrayType arrType  = (ArrayType)type;
                TypeNode  elemType = this.VisitTypeReference(arrType.ElementType);
                if (elemType == arrType.ElementType || elemType == null)
                {
                    return(arrType);
                }
                if (arrType.IsSzArray())
                {
                    return(elemType.GetArrayType(1));
                }
                return(elemType.GetArrayType(arrType.Rank, arrType.Sizes, arrType.LowerBounds));

            case NodeType.DelegateNode:
            {
                FunctionType ftype = type as FunctionType;
                if (ftype == null)
                {
                    goto default;
                }
                TypeNode referringType = ftype.DeclaringType == null ? this.CurrentType : this.VisitTypeReference(ftype.DeclaringType);
                return(FunctionType.For(this.VisitTypeReference(ftype.ReturnType), this.VisitParameterList(ftype.Parameters), referringType));
            }

            case NodeType.Pointer:
                Pointer pType = (Pointer)type;
                elemType = this.VisitTypeReference(pType.ElementType);
                if (elemType == pType.ElementType || elemType == null)
                {
                    return(pType);
                }
                return(elemType.GetPointerType());

            case NodeType.Reference:
                Reference rType = (Reference)type;
                elemType = this.VisitTypeReference(rType.ElementType);
                if (elemType == rType.ElementType || elemType == null)
                {
                    return(rType);
                }
                return(elemType.GetReferenceType());

            case NodeType.ArrayTypeExpression:
                ArrayTypeExpression aExpr = (ArrayTypeExpression)type;
                aExpr.ElementType = this.VisitTypeReference(aExpr.ElementType);
                return(aExpr);

            case NodeType.BoxedTypeExpression:
                BoxedTypeExpression bExpr = (BoxedTypeExpression)type;
                bExpr.ElementType = this.VisitTypeReference(bExpr.ElementType);
                return(bExpr);

            case NodeType.ClassExpression:
            {
                ClassExpression cExpr = (ClassExpression)type;
                cExpr.Expression = this.VisitTypeExpression(cExpr.Expression);

                //Could happen if the expression is a template parameter
                if (cExpr.Expression is Literal lit)
                {
                    return(lit.Value as TypeNode);
                }

                cExpr.TemplateArguments = this.VisitTypeReferenceList(cExpr.TemplateArguments);
                return(cExpr);
            }

            case NodeType.ClassParameter:
            case NodeType.TypeParameter:
                int key = type.UniqueKey;
                for (int i = 0, n = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; i < n && i < m; i++)
                {
                    //^ assert pars != null && args != null;
                    TypeNode tp = pars[i];
                    if (tp == null)
                    {
                        continue;
                    }
                    if (tp.UniqueKey == key)
                    {
                        return(args[i]);
                    }
                    if (tp.Name.UniqueIdKey == type.Name.UniqueIdKey && (tp is ClassParameter && type is TypeParameter))
                    {
                        //This shouldn't really happen, but in practice it does. Hack past it.
                        return(args[i]);
                    }
                }
                return(type);

            case NodeType.FlexArrayTypeExpression:
                FlexArrayTypeExpression flExpr = (FlexArrayTypeExpression)type;
                flExpr.ElementType = this.VisitTypeReference(flExpr.ElementType);
                return(flExpr);

            case NodeType.FunctionTypeExpression:
                FunctionTypeExpression ftExpr = (FunctionTypeExpression)type;
                ftExpr.Parameters = this.VisitParameterList(ftExpr.Parameters);
                ftExpr.ReturnType = this.VisitTypeReference(ftExpr.ReturnType);
                return(ftExpr);

            case NodeType.InvariantTypeExpression:
                InvariantTypeExpression invExpr = (InvariantTypeExpression)type;
                invExpr.ElementType = this.VisitTypeReference(invExpr.ElementType);
                return(invExpr);

            case NodeType.InterfaceExpression:
                InterfaceExpression iExpr = (InterfaceExpression)type;
                if (iExpr.Expression == null)
                {
                    goto default;
                }
                iExpr.Expression        = this.VisitTypeExpression(iExpr.Expression);
                iExpr.TemplateArguments = this.VisitTypeReferenceList(iExpr.TemplateArguments);
                return(iExpr);

            case NodeType.NonEmptyStreamTypeExpression:
                NonEmptyStreamTypeExpression neExpr = (NonEmptyStreamTypeExpression)type;
                neExpr.ElementType = this.VisitTypeReference(neExpr.ElementType);
                return(neExpr);

            case NodeType.NonNullTypeExpression:
                NonNullTypeExpression nnExpr = (NonNullTypeExpression)type;
                nnExpr.ElementType = this.VisitTypeReference(nnExpr.ElementType);
                return(nnExpr);

            case NodeType.NonNullableTypeExpression:
                NonNullableTypeExpression nbExpr = (NonNullableTypeExpression)type;
                nbExpr.ElementType = this.VisitTypeReference(nbExpr.ElementType);
                return(nbExpr);

            case NodeType.NullableTypeExpression:
                NullableTypeExpression nuExpr = (NullableTypeExpression)type;
                nuExpr.ElementType = this.VisitTypeReference(nuExpr.ElementType);
                return(nuExpr);

            case NodeType.OptionalModifier:
            {
                TypeModifier modType      = (TypeModifier)type;
                TypeNode     modifiedType = this.VisitTypeReference(modType.ModifiedType);
                TypeNode     modifierType = this.VisitTypeReference(modType.Modifier);
                if (modifiedType == null || modifierType == null)
                {
                    return(type);
                }

                return(OptionalModifier.For(modifierType, modifiedType));
            }

            case NodeType.RequiredModifier:
            {
                TypeModifier modType      = (TypeModifier)type;
                TypeNode     modifiedType = this.VisitTypeReference(modType.ModifiedType);
                TypeNode     modifierType = this.VisitTypeReference(modType.Modifier);
                if (modifiedType == null || modifierType == null)
                {
                    Debug.Fail(""); return(type);
                }
                return(RequiredModifier.For(modifierType, modifiedType));
            }

            case NodeType.OptionalModifierTypeExpression:
                OptionalModifierTypeExpression optmodType = (OptionalModifierTypeExpression)type;
                optmodType.ModifiedType = this.VisitTypeReference(optmodType.ModifiedType);
                optmodType.Modifier     = this.VisitTypeReference(optmodType.Modifier);
                return(optmodType);

            case NodeType.RequiredModifierTypeExpression:
                RequiredModifierTypeExpression reqmodType = (RequiredModifierTypeExpression)type;
                reqmodType.ModifiedType = this.VisitTypeReference(reqmodType.ModifiedType);
                reqmodType.Modifier     = this.VisitTypeReference(reqmodType.Modifier);
                return(reqmodType);

            case NodeType.PointerTypeExpression:
                PointerTypeExpression pExpr = (PointerTypeExpression)type;
                pExpr.ElementType = this.VisitTypeReference(pExpr.ElementType);
                return(pExpr);

            case NodeType.ReferenceTypeExpression:
                ReferenceTypeExpression rExpr = (ReferenceTypeExpression)type;
                rExpr.ElementType = this.VisitTypeReference(rExpr.ElementType);
                return(rExpr);

            case NodeType.StreamTypeExpression:
                StreamTypeExpression sExpr = (StreamTypeExpression)type;
                sExpr.ElementType = this.VisitTypeReference(sExpr.ElementType);
                return(sExpr);

            case NodeType.TupleTypeExpression:
                TupleTypeExpression tuExpr = (TupleTypeExpression)type;
                tuExpr.Domains = this.VisitFieldList(tuExpr.Domains);
                return(tuExpr);

            case NodeType.TypeExpression:
            {
                TypeExpression tExpr = (TypeExpression)type;
                tExpr.Expression = this.VisitTypeExpression(tExpr.Expression);
                if (tExpr.Expression is Literal)
                {
                    return(type);
                }
                tExpr.TemplateArguments = this.VisitTypeReferenceList(tExpr.TemplateArguments);
                return(tExpr);
            }

            case NodeType.TypeIntersectionExpression:
                TypeIntersectionExpression tiExpr = (TypeIntersectionExpression)type;
                tiExpr.Types = this.VisitTypeReferenceList(tiExpr.Types);
                return(tiExpr);

            case NodeType.TypeUnionExpression:
                TypeUnionExpression tyuExpr = (TypeUnionExpression)type;
                tyuExpr.Types = this.VisitTypeReferenceList(tyuExpr.Types);
                return(tyuExpr);

            default:
                TypeNode declaringType = this.VisitTypeReference(type.DeclaringType);
                if (declaringType != null)
                {
                    Identifier tname = type.Name;
                    if (type.Template != null && type.IsGeneric)
                    {
                        tname = type.Template.Name;
                    }
                    TypeNode nt = declaringType.GetNestedType(tname);
                    if (nt != null)
                    {
                        TypeNodeList arguments = type.TemplateArguments;
                        type = nt;
                        if (TargetPlatform.UseGenerics)
                        {
                            if (arguments != null && arguments.Count > 0 && nt.ConsolidatedTemplateParameters != null && nt.ConsolidatedTemplateParameters.Count > 0)
                            {
                                type = nt.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, arguments);
                            }
                        }
                    }
                }

                if (type.Template != null && (type.ConsolidatedTemplateParameters == null || type.ConsolidatedTemplateParameters.Count == 0))
                {
                    if (!type.IsNotFullySpecialized && (!type.IsNormalized ||
                                                        (this.CurrentType != null && type.DeclaringModule == this.CurrentType.DeclaringModule)))
                    {
                        return(type);
                    }

                    // Type is a template instance, but some of its arguments were themselves parameters.
                    // See if any of these parameters are to be specialized by this specializer.
                    bool         mustSpecializeFurther = false;
                    TypeNodeList targs   = type.TemplateArguments;
                    int          numArgs = targs == null ? 0 : targs.Count;

                    if (targs != null)
                    {
                        targs = new TypeNodeList(targs);

                        for (int i = 0; i < numArgs; i++)
                        {
                            TypeNode targ = targs[i];

                            if (targ is ITypeParameter tparg)
                            {
                                for (int j = 0, np = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; j < np && j < m; j++)
                                {
                                    //^ assert pars != null && args != null;
                                    if (TargetPlatform.UseGenerics)
                                    {
                                        if (!(pars[j] is ITypeParameter par))
                                        {
                                            continue;
                                        }

                                        if (tparg == par || (tparg.ParameterListIndex == par.ParameterListIndex && tparg.DeclaringMember == par.DeclaringMember))
                                        {
                                            targ = this.args[j];
                                            break;
                                        }
                                    }
                                    else
                                    {
                                        if (targ == pars[j])
                                        {
                                            targ = this.args[j];
                                            break;
                                        }
                                    }
                                }
                            }
                            else
                            {
                                if (targ != type)
                                {
                                    targ = this.VisitTypeReference(targ);
                                }

                                if (targ == type)
                                {
                                    continue;
                                }
                            }

                            mustSpecializeFurther |= targs[i] != targ;
                            targs[i] = targ;
                        }
                    }

                    if (targs == null || !mustSpecializeFurther)
                    {
                        return(type);
                    }

                    return(type.Template.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, targs));
                }

                TypeNodeList tPars = type.TemplateParameters;
                if (tPars == null || tPars.Count == 0)
                {
                    return(type);                                       //Not a parameterized type. No need to get an instance.
                }
                TypeNodeList tArgs = new TypeNodeList();
                for (int i = 0, n = tPars.Count; i < n; i++)
                {
                    TypeNode tPar = tPars[i];
                    tArgs.Add(tPar);     //Leave parameter in place if there is no match
                    if (tPar == null || tPar.Name == null)
                    {
                        continue;
                    }
                    int idKey = tPar.Name.UniqueIdKey;
                    for (int j = 0, m = pars == null ? 0 : pars.Count, k = args == null ? 0 : args.Count; j < m && j < k; j++)
                    {
                        //^ assert pars != null && args != null;
                        TypeNode par = pars[j];
                        if (par == null || par.Name == null)
                        {
                            continue;
                        }
                        if (par.Name.UniqueIdKey == idKey)
                        {
                            tArgs[i] = args[j];
                            break;
                        }
                    }
                }
                return(type.GetTemplateInstance(this.TargetModule, this.CurrentType, this.VisitTypeReference(type.DeclaringType), tArgs));
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Parses a simple expression (no function calls on top-level expression.
        /// </summary>
        public static bool AcceptAtom(string Text, int Start, out Expression Expression, out int LastChar)
        {
            // Procedure
            if (AcceptString(Text, Start, "{", out LastChar))
            {
                ProcedureExpression procedure;
                AcceptWhitespace(Text, LastChar, out LastChar);
                AcceptProcedure(Text, LastChar, out procedure, out LastChar);
                AcceptWhitespace(Text, LastChar, out LastChar);
                if (AcceptString(Text, LastChar, "}", out LastChar))
                {
                    Expression = procedure;
                    return true;
                }
            }

            // Variable
            Operator op;
            string varname;
            if (AcceptWord(Text, Start, out varname, out LastChar) && ValidVariable(varname) && !LookupOperator(varname, out op))
            {
                Expression = new VariableExpression(varname);
                return true;
            }

            // Parentheses
            if (AcceptString(Text, Start, "(", out LastChar))
            {
                // Operator
                int nc = LastChar;
                if (AcceptWord(Text, nc, out varname, out LastChar) && LookupOperator(varname, out op))
                {
                    if (AcceptString(Text, LastChar, ")", out LastChar))
                    {
                        Expression = new VariableExpression(varname);
                        return true;
                    }
                }

                Expression exp;
                AcceptWhitespace(Text, nc, out LastChar);
                if (AcceptExpression(Text, LastChar, out exp, out LastChar))
                {
                    AcceptWhitespace(Text, LastChar, out LastChar);
                    if (AcceptString(Text, LastChar, ")", out LastChar))
                    {
                        Expression = exp;
                        return true;
                    }
                }
            }

            // Integer literal
            long val;
            if (AcceptIntegerLiteral(Text, Start, out val, out LastChar))
            {
                Expression = new IntegerLiteralExpression(val);
                return true;
            }

            // Alternate lambda syntax
            if (AcceptString(Text, Start, "function", out LastChar))
            {
                AcceptWhitespace(Text, LastChar, out LastChar);
                if (AcceptString(Text, LastChar, "(", out LastChar))
                {
                    AcceptWhitespace(Text, LastChar, out LastChar);
                    List<KeyValuePair<Expression, string>> arglist;
                    AcceptArgumentList(Text, LastChar, out arglist, out LastChar);
                    AcceptWhitespace(Text, LastChar, out LastChar);
                    if (AcceptString(Text, LastChar, ")", out LastChar))
                    {
                        AcceptWhitespace(Text, LastChar, out LastChar);
                        if (AcceptString(Text, LastChar, "{", out LastChar))
                        {
                            ProcedureExpression procedure;
                            AcceptWhitespace(Text, LastChar, out LastChar);
                            AcceptProcedure(Text, LastChar, out procedure, out LastChar);
                            AcceptWhitespace(Text, LastChar, out LastChar);
                            if (AcceptString(Text, LastChar, "}", out LastChar))
                            {
                                Expression = new FunctionDefineExpression(arglist, procedure);
                                return true;
                            }
                        }
                    }
                }
            }

            // Function type
            if (AcceptString(Text, Start, "<", out LastChar))
            {
                AcceptWhitespace(Text, LastChar, out LastChar);
                List<KeyValuePair<Expression, string>> argtypelist;
                AcceptArgumentList(Text, LastChar, out argtypelist, out LastChar);
                AcceptWhitespace(Text, LastChar, out LastChar);
                if (AcceptString(Text, LastChar, ">", out LastChar))
                {
                    AcceptWhitespace(Text, LastChar, out LastChar);
                    Expression returntype;
                    if (AcceptTightExpression(Text, LastChar, out returntype, out LastChar))
                    {
                        Expression = new FunctionTypeExpression(argtypelist, returntype);
                        return true;
                    }
                }
            }

            Expression = null;
            return false;
        }