예제 #1
0
        internal override Expression ResolveEntityNames(ParserContext parser)
        {
            if (this.Name == "$var")
            {
                return(new CompileTimeDictionary(this.FirstToken, "var", this.Owner));
            }

            if (this.Name == "$$$")
            {
                throw new ParserException(this, "Core function invocations cannot stand alone and must be immediately invoked.");
            }

            NamespaceReferenceTemplate nrt = this.Owner.FileScope.FileScopeEntityLookup.DoNamespaceLookup(this.Name, this.TopLevelEntity);

            if (nrt != null)
            {
                return(new NamespaceReference(this.FirstToken, this.Owner, nrt));
            }

            TopLevelEntity exec = this.Owner.FileScope.FileScopeEntityLookup.DoEntityLookup(this.Name, this.Owner);

            if (exec != null)
            {
                if (!(this.Owner is ICodeContainer && ((ICodeContainer)this.Owner).ArgumentNameLookup.Contains(this.Name)))
                {
                    return(ResolverPipeline.ConvertStaticReferenceToExpression(exec, this.FirstToken, this.Owner));
                }
            }

            return(this);
        }
예제 #2
0
        internal override Executable ResolveEntityNames(ParserContext parser)
        {
            string         iterationVariableName = this.IterationVariable.Value;
            TopLevelEntity exec = this.Owner.FileScope.FileScopeEntityLookup.DoEntityLookup(iterationVariableName, this.Owner);

            if (exec != null)
            {
                throw new ParserException(this.IterationVariable, "The name '" + iterationVariableName + "' collides with an existing definition.");
            }

            this.IterationExpression = this.IterationExpression.ResolveEntityNames(parser);
            this.BatchExecutableEntityNameResolver(parser, this.Code);
            return(this);
        }
예제 #3
0
파일: Node.cs 프로젝트: jimjag/crayon
        internal static bool IsAccessAllowed(Node callerLocation, TopLevelEntity referencedEntity)
        {
            AccessModifierType invokedAccessType = referencedEntity.Modifiers.AccessModifierType;

            if (invokedAccessType == AccessModifierType.PUBLIC)
            {
                return(true);
            }

            bool sameScope = referencedEntity.CompilationScope == callerLocation.CompilationScope;

            if (invokedAccessType == AccessModifierType.INTERNAL)
            {
                return(sameScope);
            }
            if (invokedAccessType == AccessModifierType.INTERNAL_PROTECTED)
            {
                if (!sameScope)
                {
                    return(false);
                }
            }

            ClassDefinition memberClass = GetWrappingClassOfNodeIfNotAlreadyAClass(referencedEntity);
            ClassDefinition callerClass = GetWrappingClassOfNodeIfNotAlreadyAClass(callerLocation);
            bool            sameClass   = memberClass == callerClass;

            if (sameClass || invokedAccessType == AccessModifierType.PRIVATE)
            {
                return(sameClass);
            }

            // at this point, we are only left with PROTECTED and
            // INTERNAL_PROTECTED (where the INTERNAL part was already verified) and we
            // know that the calling site does not occur in the member's class.

            ClassDefinition classWalker = callerClass;

            while (classWalker != null)
            {
                classWalker = classWalker.BaseClass;
                if (classWalker == memberClass)
                {
                    return(true);
                }
            }
            return(false);
        }
예제 #4
0
 public FunctionDefinition(
     Token functionToken,
     AType returnType,
     TopLevelEntity nullableOwner,
     Token nameToken,
     ModifierCollection modifiers,
     AnnotationCollection annotations,
     FileScope fileScope)
     : base(functionToken, nullableOwner, fileScope, modifiers)
 {
     this.ReturnType         = returnType;
     this.NameToken          = nameToken;
     this.Annotations        = annotations;
     this.MemberID           = -1;
     this.Lambdas            = new List <Lambda>();
     this.ArgumentNameLookup = new HashSet <string>();
 }
예제 #5
0
        internal static void CheckIfThisOrBaseIsValid(Expression thisOrBase, ParserContext parser)
        {
            TopLevelEntity container        = thisOrBase.TopLevelEntity;
            string         thisOrBaseString = thisOrBase.FirstToken.Value;

            FunctionDefinition funcDef = container as FunctionDefinition;

            if (funcDef != null)
            {
                if (funcDef.Modifiers.HasStatic)
                {
                    throw new ParserException(thisOrBase, "Cannot use '" + thisOrBaseString + "' in a static method");
                }

                if (funcDef.Owner == null)
                {
                    throw new ParserException(thisOrBase, "Cannot use '" + thisOrBaseString + "' in a function that isn't a class method.");
                }
            }
            else
            {
                FieldDefinition fieldDef = container as FieldDefinition;
                if (fieldDef != null)
                {
                    if (fieldDef.Modifiers.HasStatic)
                    {
                        throw new ParserException(thisOrBase, "Cannot use '" + thisOrBaseString + "' in a static field value.");
                    }
                }
                else
                {
                    ConstructorDefinition ctorDef = container as ConstructorDefinition;
                    if (ctorDef != null && ctorDef.Modifiers.HasStatic)
                    {
                        throw new ParserException(thisOrBase, "Cannot use '" + thisOrBaseString + "' in a static constructor.");
                    }
                }
            }
        }
예제 #6
0
        public void ResolveBaseClasses()
        {
            List <ClassDefinition> baseClasses       = new List <ClassDefinition>();
            List <Token>           baseClassesTokens = new List <Token>();

            for (int i = 0; i < this.BaseClassDeclarations.Length; ++i)
            {
                string         value             = this.BaseClassDeclarations[i];
                Token          token             = this.BaseClassTokens[i];
                TopLevelEntity baseClassInstance = this.FileScope.FileScopeEntityLookup.DoEntityLookup(value, this);
                if (baseClassInstance == null)
                {
                    throw new ParserException(token, "No class named '" + token.Value + "' was found.");
                }

                if (baseClassInstance is ClassDefinition)
                {
                    baseClasses.Add((ClassDefinition)baseClassInstance);
                    baseClassesTokens.Add(token);
                }
                // TODO: else if (baseClassInstance is InterfaceDefinition) { ... }
                else
                {
                    throw new ParserException(token, "This is not a class.");
                }
            }

            if (baseClasses.Count > 1)
            {
                throw new ParserException(baseClassesTokens[1], "Multiple base classes found. Did you mean to use an interface?");
            }

            if (baseClasses.Count == 1)
            {
                this.BaseClass = baseClasses[0];
            }
        }
예제 #7
0
파일: DotField.cs 프로젝트: jimjag/crayon
        internal override Expression ResolveEntityNames(
            ParserContext parser)
        {
            FunctionDefinition funcDef; // used in multiple places.
            FieldDefinition    fieldDec;

            this.Root = this.Root.ResolveEntityNames(parser);
            Expression root  = this.Root;
            string     field = this.FieldToken.Value;

            if (root is NamespaceReference)
            {
                // already a fully qualified namespace, therefore imports don't matter.
                string         fullyQualifiedName = ((NamespaceReference)root).Template.Name + "." + field;
                TopLevelEntity entity             = this.Owner.FileScope.FileScopeEntityLookup.DoEntityLookup(fullyQualifiedName, parser.CurrentCodeContainer);
                if (entity != null)
                {
                    return(ResolverPipeline.ConvertStaticReferenceToExpression(entity, this.FirstToken, this.Owner));
                }

                NamespaceReferenceTemplate nrt = this.Owner.FileScope.FileScopeEntityLookup.DoNamespaceLookup(fullyQualifiedName, parser.CurrentCodeContainer);
                if (nrt != null)
                {
                    return(new NamespaceReference(this.FirstToken, this.Owner, nrt));
                }

                throw new ParserException(this, "Could not find class or function by the name of: '" + fullyQualifiedName + "'");
            }

            if (root is ClassReference)
            {
                ClassDefinition cd = ((ClassReference)root).ClassDefinition;

                funcDef = cd.GetMethod(field, false);
                if (funcDef != null)
                {
                    if (!funcDef.Modifiers.HasStatic)
                    {
                        string className    = cd.NameToken.Value;
                        string functionName = funcDef.NameToken.Value;

                        throw new ParserException(this.DotToken, "'" + className + "." + functionName + "' is not a static method, but it is being used as though it is static.");
                    }

                    Node.EnsureAccessIsAllowed(this.FieldToken, this.Owner, funcDef);

                    return(new FunctionReference(this.FirstToken, funcDef, this.Owner));
                }

                fieldDec = cd.GetField(field, false);
                if (fieldDec != null)
                {
                    if (!fieldDec.Modifiers.HasStatic)
                    {
                        throw new ParserException(this.DotToken, "Cannot make a static reference to a non-static field.");
                    }

                    Node.EnsureAccessIsAllowed(this.FieldToken, this.Owner, fieldDec);

                    return(new FieldReference(this.FirstToken, fieldDec, this.Owner));
                }

                // TODO: typeof(class name) is less error prone with localization conflicts.
                // However there's a Core.typeOf() method that sort of conflicts.
                // TODO: if this notation is kept, then this needs to be split into two class keywords
                // since they do different things.
                if (field == parser.Keywords.CLASS)
                {
                    return(new ClassReferenceLiteral(this.FirstToken, cd, this.Owner));
                }

                // TODO: nested classes, enums, constants

                // TODO: show spelling suggestions.
                throw new ParserException(this.FieldToken, "No static fields or methods named '" + field + "' on the class " + cd.NameToken.Value + ".");
            }

            if (root is BaseKeyword)
            {
                ClassDefinition thisClass = null;
                if (this.Owner != null)
                {
                    if (this.Owner is FunctionDefinition)
                    {
                        thisClass = this.Owner.Owner as ClassDefinition;
                    }
                    else
                    {
                        thisClass = this.Owner as ClassDefinition;
                    }
                }

                if (thisClass == null)
                {
                    throw new ParserException(root, "'base' keyword can only be used inside classes.");
                }

                ClassDefinition cd = thisClass.BaseClass;
                if (cd == null)
                {
                    throw new ParserException(root, "'base' keyword can only be used inside classes that extend from another class.");
                }

                FunctionDefinition fd = cd.GetMethod(field, true);
                if (fd == null)
                {
                    throw new ParserException(this.DotToken, "Cannot find a method by that name in the base class chain.");
                }

                if (fd.Modifiers.HasStatic)
                {
                    throw new ParserException(this.DotToken, "Cannot reference static methods using 'base' keyword.");
                }

                Node.EnsureAccessIsAllowed(this.DotToken, this.Owner, fd);

                return(new BaseMethodReference(this.FirstToken, this.DotToken, this.FieldToken, this.Owner));
            }

            if (root is ThisKeyword)
            {
                ClassDefinition cd    = null;
                TopLevelEntity  owner = this.TopLevelEntity;
                if (owner is FunctionDefinition)
                {
                    FunctionDefinition functionOwner = (FunctionDefinition)owner;
                    if (functionOwner.Modifiers.HasStatic)
                    {
                        throw new ParserException(this.Root, "'this' keyword cannot be used in static methods.");
                    }

                    if (!(functionOwner.Owner is ClassDefinition))
                    {
                        throw new ParserException(this.Root, "'this' keyword cannot be used in a function that isn't in a class.");
                    }

                    cd = (ClassDefinition)owner.Owner;
                }
                else if (owner is FieldDefinition)
                {
                    if (((FieldDefinition)owner).Modifiers.HasStatic)
                    {
                        throw new ParserException(this.Root, "'this' keyword cannot be used in static fields.");
                    }
                    cd = (ClassDefinition)owner.Owner;
                }
                else if (owner is ConstructorDefinition)
                {
                    if (((ConstructorDefinition)owner).Modifiers.HasStatic)
                    {
                        throw new ParserException(this.Root, "'this', keyword cannot be used in static constructors.");
                    }
                    cd = (ClassDefinition)owner.Owner;
                }
                else
                {
                    throw new ParserException(this.Root, "'this' keyword must be used inside a class.");
                }

                funcDef = cd.GetMethod(field, true);
                if (funcDef != null)
                {
                    if (funcDef.Modifiers.HasStatic)
                    {
                        throw new ParserException(this.DotToken, "This method is static and must be referenced by the class name, not 'this'.");
                    }
                    Node.EnsureAccessIsAllowed(this.DotToken, this.Owner, funcDef);
                    return(new FunctionReference(this.FirstToken, funcDef, this.Owner));
                }

                FieldDefinition fieldDef = cd.GetField(field, true);
                if (fieldDef != null)
                {
                    if (fieldDef.Modifiers.HasStatic)
                    {
                        throw new ParserException(this.DotToken, "This field is static and must be referenced by the class name, not 'this'.");
                    }
                    Node.EnsureAccessIsAllowed(this.DotToken, this.Owner, fieldDef);

                    return(new FieldReference(this.FirstToken, fieldDef, this.Owner));
                }

                // TODO: show suggestions in the error message for anything close to what was typed.
                throw new ParserException(this.FieldToken, "The class '" + cd.NameToken.Value + "' does not have a field named '" + field + "'.");
            }

            if (this.Root is EnumReference)
            {
                EnumDefinition enumDef = ((EnumReference)this.Root).EnumDefinition;

                if (field == parser.Keywords.FIELD_ENUM_LENGTH)
                {
                    return(new IntegerConstant(this.FirstToken, enumDef.Items.Length, this.Owner));
                }
                if (field == parser.Keywords.FIELD_ENUM_MAX)
                {
                    return(new SpecialEntity.EnumMaxFunction(this.FirstToken, enumDef, this.Owner));
                }
                if (field == parser.Keywords.FIELD_ENUM_VALUES)
                {
                    return(new SpecialEntity.EnumValuesFunction(this.FirstToken, enumDef, this.Owner));
                }

                return(new EnumFieldReference(this.FirstToken, enumDef, this.FieldToken, this.Owner));
            }

            // This is done here in the resolver instead of the parser because some unallowed
            // field names (such as .class) are valid.
            if (field == parser.Keywords.CLASS)
            {
                if (this.Root is Variable)
                {
                    throw new ParserException(this.Root, "'" + ((Variable)this.Root).Name + "' is not a class.");
                }
                throw new ParserException(this.DotToken, ".class can only be applied to class names.");
            }
            parser.VerifyIdentifier(this.FieldToken);

            return(this);
        }
예제 #8
0
파일: Node.cs 프로젝트: jimjag/crayon
 internal static void EnsureAccessIsAllowed(Token throwToken, Node callerLocation, TopLevelEntity referencedEntity)
 {
     if (!IsAccessAllowed(callerLocation, referencedEntity))
     {
         // TODO: better wording: "The field/function 'foo' is not visible from the class 'FooClass' due to its access scope."
         // TODO: even better: "...it is marked as protected but does not inherit from 'AbstractFooClass'" etc.
         throw new ParserException(throwToken, "This class member is not visible from here due to its access scope.");
     }
 }