internal override Expression ResolveEntityNames(ParserContext parser) { this.BatchExpressionEntityNameResolver(parser, this.Args); // TODO: localize or create a dummy stub in Core if (this.Name == "List") { return(new ListDefinition(this.FirstToken, new List <Expression>(), this.Generics[0], this.Owner, false, null)); } else if (this.Name == "Dictionary") { return(new DictionaryDefinition( this.FirstToken, this.Generics[0], this.Generics[1], new List <Expression>(), new List <Expression>(), this.Owner)); } this.Class = this.FileScope.DoClassLookup(this.Owner, this.NameToken, this.Name); if (this.Class == null) { throw new ParserException(this, "No class named '" + this.Name + "'"); } if (this.Class.Modifiers.HasStatic) { throw new ParserException(this, "Cannot instantiate a static class."); } Node.EnsureAccessIsAllowed(this.FirstToken, this.Owner, this.Class); if (!Node.IsAccessAllowed(this.Owner, this.Class.Constructor)) { // TODO: word this better. Maybe just say "this class' constructor is marked as private/protected/etc" throw new ParserException(this.FirstToken, "This class' constructor's access modifier does not allow it to be constructed here."); } this.ConstructorReference = this.Class.Constructor; int minArgCount = 0; int maxArgCount = 0; bool isPrivate = false; if (this.ConstructorReference != null) { minArgCount = this.ConstructorReference.MinArgCount; maxArgCount = this.ConstructorReference.MaxArgCount; isPrivate = this.ConstructorReference.Annotations.IsPrivate(); } if (isPrivate) { bool isValidUsage = this.Class == this.Owner || // used in a field where the owner is the class directly this.Class == this.Owner.Owner; // used in a function where the owner is the method whose owner is the class. if (!isValidUsage) { throw new ParserException(this, "The constructor for " + this.Class.NameToken.Value + " is private and cannot be invoked from outside the class."); } } if (this.Args.Length < minArgCount || this.Args.Length > maxArgCount) { string message = "This constructor has the wrong number of arguments. "; if (minArgCount == maxArgCount) { message += "Expected " + minArgCount + " but found " + this.Args.Length; } else if (this.Args.Length < minArgCount) { message += " At least " + minArgCount + " are required but found only " + this.Args.Length + "."; } else { message += " At most " + maxArgCount + " are allowed but found " + this.Args.Length + "."; } throw new ParserException(this, message); } return(this); }
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); }