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);
}
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);
}
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);
}
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>();
}
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.");
}
}
}
}
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];
}
}
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);
}
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.");
}
}
