protected virtual void GetCodeType()
{
if (_canInferType && (_contextHandler.GetCodeType() == null || _contextHandler.GetCodeType().Infer) && ComponentCollection.IsComponent <InitialValueComponent>())
{
_varInfo.InferType = true;
}
else
{
CodeType type;
if (_contextHandler.GetCodeType() == null)
{
type = _parseInfo.TranslateInfo.Types.Any();
}
else
{
// Get the type.
type = TypeFromContext.GetCodeTypeFromContext(
_parseInfo,
_scope,
_contextHandler.GetCodeType()
);
}
ApplyCodeType(type);
}
}
public VariableApply(ParseInfo parseInfo, Scope scope, Scope getter, IVariableInstance variable, Identifier variableContext)
{
Variable = variable;
_parseInfo = parseInfo;
_name = variableContext.Token.Text;
CallRange = variableContext.Token.Range;
getter = getter ?? scope;
// Get the index.
if (variableContext.Index != null)
{
_index = new IExpression[variableContext.Index.Count];
for (int i = 0; i < _index.Length; i++)
{
_index[i] = parseInfo.GetExpression(scope, variableContext.Index[i].Expression, getter: getter);
}
}
// Get the generics.
if (variableContext.TypeArgs != null)
{
_generics = new CodeType[variableContext.TypeArgs.Count];
for (int i = 0; i < _generics.Length; i++)
{
_generics[i] = TypeFromContext.GetCodeTypeFromContext(parseInfo, getter, variableContext.TypeArgs[i]);
}
}
VariableCall = Variable.GetExpression(_parseInfo, CallRange, _index, _generics);
}
public CreateObjectAction(ParseInfo parseInfo, Scope scope, NewExpression context)
{
if (!context.Type.Valid)
{
CreatingObjectOf = parseInfo.Types.Any();
return;
}
// Get the type. Syntax error if there is no type name.
CreatingObjectOf = TypeFromContext.GetCodeTypeFromContext(parseInfo, scope, context.Type);
DocRange nameRange = context.Type.GenericToken.Range;
// Get the constructor to use.
OverloadChooser = new OverloadChooser(
CreatingObjectOf.Constructors.Select(c => new ConstructorOverload(c)).ToArray(),
parseInfo,
CreatingObjectOf.ReturningScope(),
scope,
nameRange,
context.Range,
context.Range,
new OverloadError("type " + CreatingObjectOf.Name)
);
OverloadChooser.Apply(context.Parameters, false, null);
Constructor = (Constructor)OverloadChooser.Overload;
if (Constructor != null)
{
Constructor.Call(parseInfo, nameRange);
parseInfo.Script.AddHover(context.Range, Constructor.GetLabel(parseInfo.TranslateInfo, LabelInfo.Hover));
// Default restricted parameter values.
OverloadChooser.Match.CheckOptionalsRestrictedCalls(parseInfo, nameRange);
// Bridge other restricted values.
if (Constructor.CallInfo != null)
{
RestrictedCall.BridgeMethodCall(parseInfo, Constructor.CallInfo, nameRange, context.Type.GenericToken.Text, Constructor.RestrictedValuesAreFatal);
}
}
}
private DefinedMethodProvider(ParseInfo parseInfo, IScopeHandler scopeProvider, FunctionContext context, IDefinedTypeInitializer containingType)
{
_parseInfo = parseInfo;
Context = context;
ContainingType = containingType;
CallInfo = new CallInfo(new RecursiveCallHandler(this, context.Subroutine || context.Attributes.Recursive), parseInfo.Script, ContentReady);
DocRange nameRange = context.Identifier.Range;
// Get the attributes.
var attributes = new GenericAttributeAppender(AttributeType.Ref, AttributeType.In, AttributeType.GlobalVar, AttributeType.PlayerVar);
AttributesGetter.GetAttributes(parseInfo.Script.Diagnostics, context.Attributes, attributes);
// Set the attributes.
Static = attributes.IsStatic;
Recursive = attributes.IsRecursive;
Virtual = attributes.IsVirtual;
AccessLevel = attributes.Accessor;
Recursive = attributes.IsRecursive;
// Get subroutine info.
if (context.Subroutine)
{
IsSubroutine = true;
SubroutineName = context.Subroutine.Text.RemoveQuotes();
SubroutineDefaultGlobal = !context.PlayerVar;
}
// Setup the scope.
var containingScope = scopeProvider.GetScope(Static);
containingScope.MethodContainer = true;
_methodScope = containingScope.Child(true);
// Get the generics.
GenericTypes = AnonymousType.GetGenerics(parseInfo, context.TypeArguments, this);
foreach (var type in GenericTypes)
{
_methodScope.AddType(new GenericCodeTypeInitializer(type));
}
// Get the type.
if (!context.Type.IsVoid)
{
ReturnType = TypeFromContext.GetCodeTypeFromContext(parseInfo, _methodScope, context.Type);
}
// Setup the parameters.
ParameterProviders = ParameterProvider.GetParameterProviders(parseInfo, _methodScope, context.Parameters, IsSubroutine);
ParameterTypes = ParameterProviders.Select(p => p.Type).ToArray();
// Override
if (attributes.IsOverride)
{
OverridingFunction = (DefinedMethodInstance)scopeProvider.GetOverridenFunction(parseInfo.TranslateInfo, new FunctionOverrideInfo(Name, ParameterTypes));
if (OverridingFunction == null)
{
SemanticsHelper.CouldNotOverride(parseInfo, nameRange, "method");
}
}
// Check conflicts and add to scope.
scopeProvider.CheckConflict(parseInfo, new(Name, ParameterTypes), nameRange);
scopeProvider.Add(GetDefaultInstance(scopeProvider.DefinedIn()), Static);
// Add LSP elements
// Hover
parseInfo.Script.AddHover(nameRange, GetLabel(parseInfo.TranslateInfo, LabelInfo.Hover));
// 'references' code lens
parseInfo.Script.AddCodeLensRange(new ReferenceCodeLensRange(this, parseInfo, CodeLensSourceType.Function, DefinedAt.range));
// Rename & go-to-definition
parseInfo.Script.Elements.AddDeclarationCall(this, new DeclarationCall(nameRange, true));
// todo: 'override' code lens
// if (Attributes.IsOverrideable)
// parseInfo.Script.AddCodeLensRange(new ImplementsCodeLensRange(this, parseInfo.Script, CodeLensSourceType.Function, nameRange));
// Add the CallInfo to the recursion check.
parseInfo.TranslateInfo.GetComponent <RecursionCheckComponent>().AddCheck(CallInfo);
// Queue content for staged initiation.
parseInfo.TranslateInfo.StagedInitiation.On(this);
}
public void GetMeta()
{
// Setup scopes.
_operationalStaticScope = _parseInfo.TranslateInfo.RulesetScope.Child(Name);
_operationalObjectScope = _parseInfo.TranslateInfo.RulesetScope.Child(Name);
// Add typeargs to scopes.
foreach (var type in GenericTypes)
{
_operationalStaticScope.AddType(new GenericCodeTypeInitializer(type));
_operationalObjectScope.AddType(new GenericCodeTypeInitializer(type));
}
// Get the type being extended.
// This is an array for future interface support.
if (_typeContext.Inheriting.Count > 0)
{
var inheritContext = _typeContext.Inheriting[0];
// Get the type being inherited.
var inheriting = TypeFromContext.GetCodeTypeFromContext(_parseInfo, _operationalStaticScope, inheritContext);
// GetCodeType will return null if the type is not found.
if (inheriting != null)
{
inheriting.Call(_parseInfo, inheritContext.Range);
TryToExtend(inheriting, inheritContext.GenericToken.GetRange(inheritContext.Range));
}
}
WorkingInstance = GetInstance();
// Get declarations.
foreach (var declaration in _typeContext.Declarations)
{
DeclaredElements.Add(((IDefinedTypeInitializer)this).ApplyDeclaration(declaration, _parseInfo));
}
// Get the constructors.
if (_typeContext.Constructors.Count > 0)
{
Constructors = new IConstructorProvider <Constructor> [_typeContext.Constructors.Count];
for (int i = 0; i < Constructors.Length; i++)
{
Constructors[i] = new DefinedConstructorProvider(this, _parseInfo, _operationalObjectScope, _typeContext.Constructors[i]);
}
}
else
{
// If there are no constructors, create a default constructor.
Constructors = new IConstructorProvider <Constructor>[] {
new EmptyConstructorProvider(DefinedAt)
};
}
(Extends as ClassType)?.Elements.AddToScope(_parseInfo.TranslateInfo, _operationalStaticScope, false);
(Extends as ClassType)?.Elements.AddToScope(_parseInfo.TranslateInfo, _operationalObjectScope, true);
_onReady.Set();
// TODO: update these
// If the extend token exists, add completion that only contains all extendable classes.
// if (_typeContext.InheritToken != null)
// _parseInfo.Script.AddCompletionRange(new CompletionRange(
// // Get the completion items of all types.
// _parseInfo.TranslateInfo.Types.AllTypes
// .Where(t => t is ClassType ct && ct.CanBeExtended)
// .Select(t => t.GetCompletion())
// .ToArray(),
// // Get the completion range.
// _typeContext.InheritToken.Range.End + _parseInfo.Script.NextToken(_typeContext.InheritToken).Range.Start,
// // This completion takes priority.
// CompletionRangeKind.ClearRest
// ));
// _parseInfo.Script.AddCodeLensRange(new ReferenceCodeLensRange(this, _parseInfo, CodeLensSourceType.Type, _definedAt.range));
}