CompatibleLambda CreateCompatibleLambda(InstanceAnonymousTypeLinker typeLinker, IWorkshopPortableFunctionIdentifier portableFunction)
{
var compatibleLambda = new CompatibleLambda(_assignCurrentIdentifier++, portableFunction.CreateRunner(_parameterRecycler), typeLinker);
_parameterRecycler.Reset();
_compatibleLambdas.Add(compatibleLambda);
return(compatibleLambda);
}
public override CodeType GetRealType(InstanceAnonymousTypeLinker instanceInfo)
{
if (!Attributes.ContainsGenerics)
{
return(this);
}
return(new PortableLambdaType(new PortableLambdaTypeBuilder(
kind: LambdaKind,
name: Name,
parameters: Parameters.Select(p => p.GetRealType(instanceInfo)).ToArray(),
returnType: ReturnType?.GetRealType(instanceInfo),
returnsValue: ReturnsValue,
parameterTypesKnown: ParameterTypesKnown)));
}
// Gets a CompatibleLambda that supports the provided type linker and portable function.
CompatibleLambda GetCompatibleLambda(InstanceAnonymousTypeLinker typeLinker, IWorkshopPortableFunctionIdentifier portableFunction)
{
// Iterate through each compatible lambda.
foreach (var compatibleLambda in _compatibleLambdas)
{
// Make sure the keys match and the type linker is compatible..
if (compatibleLambda.Runner.Key == portableFunction.Key &&
compatibleLambda.TypeLinker.Compatible(typeLinker))
{
// This lambda is compatible with the provided lambda.
return(compatibleLambda);
}
}
// No compatible lambdas were found.
return(null);
}
public bool HasParameterErrors => _parameterErrors.Any(p => p != null); // Are there any parameter errors?
public OverloadMatch(IOverload option, InstanceAnonymousTypeLinker typeArgLinker, ParseInfo parseInfo, DocRange inferenceErrorRange)
{
Option = option;
_parseInfo = parseInfo;
_inferenceErrorRange = inferenceErrorRange;
_parameterErrors = new OverloadMatchError[option.Parameters.Length];
if (typeArgLinker != null)
{
TypeArgLinker = typeArgLinker;
TypeArgs = typeArgLinker.TypeArgsFromAnonymousTypes(option.GenericTypes);
}
else
{
TypeArgLinker = new InstanceAnonymousTypeLinker();
TypeArgs = new CodeType[option.TypeArgCount];
}
}
public DefinedConstructorInstance(
CodeType typeInstance,
DefinedConstructorProvider provider,
InstanceAnonymousTypeLinker typeLinker,
Location definedAt
) : base(typeInstance, definedAt, AccessLevel.Public)
{
Provider = provider;
_typeLinker = typeLinker;
Parameters = new CodeParameter[provider.ParameterProviders.Length];
ParameterVars = new IVariableInstance[Parameters.Length];
for (int i = 0; i < Parameters.Length; i++)
{
var parameterInstance = provider.ParameterProviders[i].GetInstance(typeLinker);
ParameterVars[i] = parameterInstance.Variable;
Parameters[i] = parameterInstance.Parameter;
}
CallInfo = Provider.CallInfo;
RestrictedValuesAreFatal = Provider.SubroutineName == null;
}
public UserFunctionController(ToWorkshop toWorkshop, DefinedMethodInstance function, InstanceAnonymousTypeLinker typeArgs)
{
_toWorkshop = toWorkshop;
_function = function;
_typeArgLinker = typeArgs;
_allVirtualOptions.Add(function);
Attributes.IsRecursive = function.Attributes.Recursive;
// If the function is defined in a type.
if (function.DefinedInType != null)
{
Attributes.IsInstance = true;
var relations = new MethodClassRelations(toWorkshop, function);
// Get the class relation.
_classRelation = relations.ClassRelation;
// Extract the virtual functions.
_allVirtualOptions.AddRange(relations.Overriders);
}
}
public GetTypeName(bool makeAnonymousTypesUnknown, InstanceAnonymousTypeLinker typeLinker)
{
MakeAnonymousTypesUnknown = makeAnonymousTypesUnknown;
TypeLinker = typeLinker;
}
public DefinedConstructorInstance GetInstance(CodeType typeInstance, InstanceAnonymousTypeLinker genericsLinker) => new DefinedConstructorInstance(typeInstance, this, genericsLinker, DefinedAt);
public GetVariablesAssigner(InstanceAnonymousTypeLinker typeLinker)
{
TypeLinker = typeLinker;
IsGlobal = true;
Tag = null;
}
public GetVariablesAssigner(ActionSet actionSet, string tag)
{
TypeLinker = actionSet?.ThisTypeLinker;
IsGlobal = actionSet?.IsGlobal ?? true;
Tag = tag;
}
public GetVariablesAssigner(ActionSet actionSet)
{
TypeLinker = actionSet?.ThisTypeLinker;
IsGlobal = actionSet?.IsGlobal ?? true;
Tag = null;
}
public CompatibleLambda(int identifier, IWorkshopPortableFunctionRunner runner, InstanceAnonymousTypeLinker typeLinker)
{
Identifier = identifier;
Runner = runner;
TypeLinker = typeLinker;
}
public Constructor GetInstance(CodeType initializedType, InstanceAnonymousTypeLinker genericsLinker) => new Constructor(initializedType, _definedAt, AccessLevel.Public);
