private void ValidateAttribute(FileDiagnostics diagnostics, MethodAttributeContext newAttribute)
{
// The attribute is not allowed.
if (DisallowAttributes().Contains(newAttribute.Type))
{
diagnostics.Error("The '" + newAttribute.Type.ToString().ToLower() + "' attribute is not allowed.", newAttribute.Range);
}
else
{
// Virtual attribute on a static method (static attribute was first.)
if (ResultAppender.IsStatic() && newAttribute.Type == MethodAttributeType.Virtual)
{
diagnostics.Error("Static methods cannot be virtual.", newAttribute.Range);
}
// Static attribute on a virtual method (virtual attribute was first.)
if (ResultAppender.IsVirtual() && newAttribute.Type == MethodAttributeType.Static)
{
diagnostics.Error("Virtual methods cannot be static.", newAttribute.Range);
}
}
}
protected void Inherit(CodeType extend, FileDiagnostics diagnostics, DocRange range)
{
if (extend == null)
{
throw new ArgumentNullException(nameof(extend));
}
string errorMessage = null;
if (!extend.CanBeExtended)
{
errorMessage = "Type '" + extend.Name + "' cannot be inherited.";
}
else if (extend == this)
{
errorMessage = "Cannot extend self.";
}
else if (extend.Implements(this))
{
errorMessage = $"The class {extend.Name} extends this class.";
}
if (errorMessage != null)
{
if (diagnostics == null || range == null)
{
throw new Exception(errorMessage);
}
else
{
diagnostics.Error(errorMessage, range);
return;
}
}
Extends = extend;
}
public bool Apply(FileDiagnostics diagnostics, AttributeContext attribute)
{
if (_disallowedAttributes.Contains(attribute.Type))
{
diagnostics.Error("The '" + attribute.Type.ToString().ToLower() + "' attribute is not allowed.", attribute.Range);
return(false);
}
// Apply the attribute.
switch (attribute.Type)
{
// Accessors
case AttributeType.Public: Accessor = AccessLevel.Public; break;
case AttributeType.Protected: Accessor = AccessLevel.Protected; break;
case AttributeType.Private: Accessor = AccessLevel.Private; break;
// Apply static
case AttributeType.Static: IsStatic = true; break;
// Apply virtual
case AttributeType.Virtual: IsVirtual = true; break;
// Apply override
case AttributeType.Override: IsOverride = true; break;
// Apply Recursive
case AttributeType.Recursive: IsRecursive = true; break;
// Apply Variables
default: throw new NotImplementedException();
}
return(true);
}
public void Reject(FileDiagnostics diagnostics)
{
switch (Type)
{
// Accessors
case AttributeType.Public:
case AttributeType.Protected:
case AttributeType.Private:
diagnostics.Error("Accessor not valid here.", Range);
break;
// Workshop ID override
case AttributeType.ID:
diagnostics.Error($"Cannot override workshop variable ID here.", Range);
break;
// Extended collection
case AttributeType.Ext:
diagnostics.Error($"Cannot put variable in the extended collection.", Range);
break;
// Initial value
case AttributeType.Initial:
diagnostics.Error($"Variable cannot have an initial value.", Range);
break;
// Use attribute name
case AttributeType.Static:
case AttributeType.Globalvar:
case AttributeType.Playervar:
case AttributeType.Ref:
default:
diagnostics.Error($"'{Type.ToString().ToLower()}' attribute not valid here.", Range);
break;
}
}
/// <summary>
/// Adds a method to the current scope.
/// When handling methods added by the user, supply the diagnostics and range to show the syntax error at.
/// When handling methods added internally, have the diagnostics and range parameters be null. An exception will be thrown instead if there is a syntax error.
/// </summary>
/// <param name="method">The method that will be added to the current scope. If the object reference is already in the direct scope, an exception will be thrown.</param>
/// <param name="diagnostics">The file diagnostics to throw errors with. Should be null when adding methods internally.</param>
/// <param name="range">The document range to throw errors at. Should be null when adding methods internally.</param>
public void AddMethod(IMethod method, FileDiagnostics diagnostics, DocRange range, bool checkConflicts = true)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (checkConflicts && HasConflict(method))
{
string message = "A method with the same name and parameter types was already defined in this scope.";
if (diagnostics != null && range != null)
{
diagnostics.Error(message, range);
return;
}
else
{
throw new Exception(message);
}
}
AddNativeMethod(method);
}
public Var GetVar()
{
_parseInfo = _contextHandler.ParseInfo;
_diagnostics = _parseInfo.Script.Diagnostics;
_nameRange = _contextHandler.GetNameRange();
// Get the attributes.
_attributes = _contextHandler.GetAttributes();
// Stores all values in the enum AttributeType as a list.
List <AttributeType> missingTypes = Enum.GetValues(typeof(AttributeType)).Cast <AttributeType>().ToList();
// Filter missing attributes.
foreach (VarBuilderAttribute attribute in _attributes)
{
missingTypes.Remove(attribute.Type);
}
// Check missing attributes.
MissingAttribute(missingTypes.ToArray());
// Check existing attributes.
CheckAttributes();
// Create the varinfo.
_varInfo = new VarInfo(_contextHandler.GetName(), _contextHandler.GetDefineLocation(), _parseInfo);
// Get the variable type.
_typeRange = _contextHandler.GetTypeRange();
GetCodeType();
if (_varInfo.Type is Lambda.PortableLambdaType)
{
_varInfo.TokenType = TokenType.Function;
}
// Apply attributes.
foreach (VarBuilderAttribute attribute in _attributes)
{
attribute.Apply(_varInfo);
}
Apply();
// Set the variable and store types.
if (_varInfo.IsWorkshopReference)
{
// If the variable is a workshop reference, set the variable type to ElementReference.
_varInfo.VariableType = VariableType.ElementReference;
_varInfo.StoreType = StoreType.None;
}
// In extended collection.
else if (_varInfo.InExtendedCollection)
{
_varInfo.StoreType = StoreType.Indexed;
}
// Full workshop variable.
else
{
_varInfo.StoreType = StoreType.FullVariable;
}
TypeCheck();
_varInfo.Recursive = IsRecursive();
// Set the scope.
var scope = OperationalScope();
_varInfo.OperationalScope = scope;
// Get the resulting variable.
var result = new Var(_varInfo);
// Add the variable to the operational scope.
if (_contextHandler.CheckName())
{
scope.AddVariable(result, _diagnostics, _nameRange);
}
else
{
scope.CopyVariable(result);
}
return(result);
}
public VariableResolve(VariableResolveOptions options, IExpression expression, DocRange expressionRange, FileDiagnostics diagnostics)
{
// The expression is a variable.
if (expression is CallVariableAction)
{
// Get the variable being set and the range.
SetVariable = (CallVariableAction)expression;
VariableRange = expressionRange;
}
// The expression is an expression tree.
else if (expression is ExpressionTree tree)
{
Tree = tree;
if (tree.Completed)
{
// If the resulting expression in the tree is not a variable.
if (tree.Result is CallVariableAction == false)
{
NotAVariableRange = tree.ExprContextTree.Last().GetRange();
}
else
{
// Get the variable and the range.
SetVariable = (CallVariableAction)tree.Result;
VariableRange = tree.ExprContextTree.Last().GetRange();
}
}
}
// The expression is not a variable.
else if (expression != null)
{
NotAVariableRange = expressionRange;
}
// NotAVariableRange will not be null if the resulting expression is a variable.
if (NotAVariableRange != null)
{
diagnostics.Error("Expected a variable.", NotAVariableRange);
}
// Make sure the variable can be set to.
if (SetVariable != null)
{
// Check if the variable is settable.
if (options.ShouldBeSettable && !SetVariable.Calling.Settable())
{
diagnostics.Error($"The variable '{SetVariable.Calling.Name}' cannot be set to.", VariableRange);
}
// Check if the variable is a whole workshop variable.
if (options.FullVariable)
{
Var asVar = SetVariable.Calling as Var;
if (asVar == null || asVar.StoreType != StoreType.FullVariable)
{
diagnostics.Error($"The variable '{SetVariable.Calling.Name}' cannot be indexed.", VariableRange);
}
}
// Check for indexers.
if (!options.CanBeIndexed && SetVariable.Index.Length != 0)
{
diagnostics.Error($"The variable '{SetVariable.Calling.Name}' cannot be indexed.", VariableRange);
}
}
DoesResolveToVariable = SetVariable != null;
}
public FileImporter(FileDiagnostics diagnostics, Importer importer)
{
Diagnostics = diagnostics;
Importer = importer;
}
public void OutputComment(FileDiagnostics diagnostics, DocRange range, string comment)
{
Comment = comment;
}
public void Copy(FileDiagnostics diagnostics)
{
diagnostics.Error($"Multiple '{Type.ToString().ToLower()}' attributes.", Range);
}
/// <summary>Sets the related output comment. This assumes that the result is both an IExpression and an IStatement.</summary> public void OutputComment(FileDiagnostics diagnostics, DocRange range, string comment) => ((IStatement)Result).OutputComment(diagnostics, range, comment);
public void OutputComment(FileDiagnostics diagnostics, DocRange range, string comment) => Result?.SetComment(comment);
public Var GetVar()
{
_parseInfo = _contextHandler.ParseInfo;
_diagnostics = _parseInfo.Script.Diagnostics;
_nameRange = _contextHandler.GetNameRange();
// Get the attributes.
_attributes = _contextHandler.GetAttributes();
// Stores all values in the enum AttributeType as a list.
List <AttributeType> missingTypes = Enum.GetValues(typeof(AttributeType)).Cast <AttributeType>().ToList();
// Filter missing attributes.
foreach (VarBuilderAttribute attribute in _attributes)
{
missingTypes.Remove(attribute.Type);
}
// Check missing attributes.
MissingAttribute(missingTypes.ToArray());
// Check existing attributes.
CheckAttributes();
// Create the varinfo.
_varInfo = new VarInfo(_contextHandler.GetName(), _contextHandler.GetDefineLocation(), _parseInfo);
// Get the variable type.
_typeRange = _contextHandler.GetTypeRange();
GetCodeType();
// Apply attributes.
foreach (VarBuilderAttribute attribute in _attributes)
{
attribute.Apply(_varInfo);
}
Apply();
// Set the variable and store types.
if (_varInfo.IsWorkshopReference)
{
// If the variable is a workshop reference, set the variable type to ElementReference.
_varInfo.VariableType = VariableType.ElementReference;
_varInfo.StoreType = StoreType.None;
}
// In extended collection.
else if (_varInfo.InExtendedCollection)
{
_varInfo.StoreType = StoreType.Indexed;
}
// Full workshop variable.
else
{
_varInfo.StoreType = StoreType.FullVariable;
}
TypeCheck();
return(new Var(_varInfo));
}
public void Add(FileDiagnostics fileDiagnostics)
{
ThrowIfFileIsAlreadyAdded(fileDiagnostics.Uri);
diagnosticFiles.Add(fileDiagnostics);
}
public VariableResolveErrorHandler(FileDiagnostics diagnostics)
{
_diagnostics = diagnostics;
}
