public static CodeType GetCodeTypeFromContext(ParseInfo parseInfo, LambdaType type)
{
// Get the lambda type's parameters.
var parameters = new CodeType[type.Parameters.Count];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = GetCodeTypeFromContext(parseInfo, type.Parameters[i]);
// Constant types are not allowed.
if (parameters[i] != null && parameters[i].IsConstant())
{
parseInfo.Script.Diagnostics.Error("The constant type '" + parameters[i].GetName() + "' cannot be used in method types", type.Parameters[i].Range);
}
}
// Get the return type.
CodeType returnType = null;
bool returnsValue = false;
if (!type.ReturnType.IsVoid)
{
returnType = GetCodeTypeFromContext(parseInfo, type.ReturnType);
returnsValue = true;
}
return(new PortableLambdaType(LambdaKind.Portable, parameters, returnsValue, returnType, true));
}
protected Bot(Checker myColor, double? lambda = null, LambdaType? lambdaType = null)
{
Debug.Assert(myColor != Checker.Empty);
MyColor = myColor;
Lambda = lambda ?? 0.05;
LambdaType = lambdaType ?? LambdaType.ProbabilityDistribution;
}
public IWorkshopTree Parse(ActionSet actionSet)
{
// If the lambda type is constant, return the lambda itself.
if (LambdaType.IsConstant())
{
return(new LambdaActionWorkshopInstance(actionSet, this));
}
// Otherwise, return an array containing data of the lambda.
var lambdaMeta = new List <IWorkshopTree>();
// The first element is the lambda's identifier.
lambdaMeta.Add(new V_Number(Identifier));
// The second element is the 'this' if applicable.
lambdaMeta.Add(actionSet.This ?? new V_Null());
// Every proceeding element is a captured local variable.
foreach (var capture in CapturedVariables)
{
lambdaMeta.Add(actionSet.IndexAssigner[capture].GetVariable());
}
// Return the array.
return(Element.CreateArray(lambdaMeta.ToArray()));
}
public Lambda(Type propertyType, string peopertyName, LambdaType lambdaType, dynamic value)
{
PropertyType = propertyType;
PropertyName = peopertyName;
LambdaType = lambdaType;
Value = value;
}
protected Bot(Checker myColor, double?lambda = null, LambdaType?lambdaType = null)
{
Debug.Assert(myColor != Checker.Empty);
MyColor = myColor;
Lambda = lambda ?? 0.05;
LambdaType = lambdaType ?? LambdaType.ProbabilityDistribution;
}
public override void SurroundWith(Environment environment)
{
Env = environment;
Body.SurroundWith(Env);
Type = new LambdaType(MetaData, (
from i in ParameterList
select i.Type).ToList(), DeclaredType);
}
public void Finalize(PortableLambdaType expecting)
{
// Check if the current lambda implements the expected type.
if (!LambdaType.Implements(expecting))
{
_parseInfo.Script.Diagnostics.Error("Expected lambda of type '" + expecting.GetName() + "'", _context.Arrow.Range);
}
}
public IWorkshopTree Parse(ActionSet actionSet, MethodCall methodCall)
{
if (LambdaType.IsConstant())
{
ILambdaInvocable lambda = (ILambdaInvocable)actionSet.CurrentObject;
return(lambda.Invoke(actionSet, methodCall.ParameterValues));
}
return(actionSet.ToWorkshop.LambdaBuilder.Call(actionSet, methodCall, LambdaType.ReturnType));
}
public bool Equals(LambdaExpression compareNode)
{
return
(compareNode != null &&
LambdaType?.Equals(compareNode.LambdaType) != false &&
ReturnType?.Equals(compareNode.ReturnType) != false &&
SemanticProperties?.Equals(compareNode.SemanticProperties) != false &&
base.Equals(compareNode));
}
public IWorkshopTree Parse(ActionSet actionSet)
{
// If the lambda type is constant, return the lambda itself.
if (LambdaType.IsConstant())
{
return(new LambdaActionWorkshopInstance(actionSet, this));
}
// Encode the lambda.
return(Workshop.CaptureEncoder.Encode(actionSet, this));
}
private static void GenFunction(
LLVMModuleRef module,
LLVMBuilderRef builder,
[NotNull] VariableDeclaration variable,
[NotNull] LambdaType lambdaType)
{
var function = LLVMSharp.LLVM.AddFunction(module, variable.Name, GetLlvmType(lambdaType));
LLVMSharp.LLVM.PositionBuilderAtEnd(builder, LLVMSharp.LLVM.AppendBasicBlock(function, "entry"));
GenAstHolder.GenAst(module, builder, (LambdaExpression)variable.Expression);
LLVMSharp.LLVM.VerifyFunction(function, LLVMVerifierFailureAction.LLVMPrintMessageAction);
}
public LambdaType GetLambda(int id)
{
LambdaType lambda;
if (CollisionSystem.warmStarting && prevLambdas.TryGetValue(id, out var l))
{
lambda = l;
}
else
{
lambda = new LambdaType();
}
return(lambda);
}
public NeuralNetBot(Checker myColor, Network network, double? lambda=null, LambdaType? lambdaType=null)
: base(myColor, lambda, lambdaType)
{
Network = network;
}
public Scope ReturningScope() => LambdaType.GetObjectScope();
public Lambda(LambdaType func, string[] parms)
{
Delegate = func;
Params = parms;
}
/// <inheritdoc/>
public ClientResponse <LambdaResponse> RetrieveLambdasByType(LambdaType type)
{
return(client.RetrieveLambdasByTypeAsync(type).GetAwaiter().GetResult());
}
public override void SurroundWith(Environment environment)
{
base.SurroundWith(environment);
if (DeclaredType is UnknownType unknownType)
{
unknownType.SurroundWith(Env);
DeclaredType = unknownType.Resolve();
}
foreach (var variableDeclaration in ParameterList)
{
variableDeclaration.SurroundWith(Env);
}
EndLabel.SurroundWith(Env);
var bodyEnv = new Environment(Env);
Env.Declarations.Add(EndLabel);
foreach (var variableDeclaration in ParameterList)
{
bodyEnv.Declarations.Add(variableDeclaration);
}
// https://github.com/Cm-lang/Cm-Document/issues/12
if (null != DeclaredType)
{
Type = new LambdaType(MetaData, (
from i in ParameterList
select i.Type).ToList(), DeclaredType);
}
if (Recur)
{
// FEATURE #37
var recur = new VariableDeclaration(MetaData, ReservedWords.Recur, this);
// FEATURE #39
recur.SurroundWith(Env);
bodyEnv.Declarations.Add(recur);
}
Body.SurroundWith(bodyEnv);
// while (null != Body.OptimizedStatementList)
// Body = Body.OptimizedStatementList;
while (null != Body.ConvertedStatementList)
{
Body = Body.ConvertedStatementList;
}
Body.Statements.Add(EndLabel);
var retTypes = EndLabel.StatementsUsingThis.Select(i =>
{
i.ReturnLabel = EndLabel;
return(i.Expression.GetExpressionType());
}).ToList();
// Body.Flatten();
if (retTypes.Any(i => !Equals(i, DeclaredType ?? retTypes.First())))
{
Errors.Add(
$"{MetaData.GetErrorHeader()}ambiguous return types:\n" +
(DeclaredType != null ? $"<{DeclaredType}>" : "") +
$"[{string.Join(",", from i in retTypes select i.ToString())}]");
}
// FEATURE #12
var retType = DeclaredType ?? (retTypes.Count != 0
? retTypes.First()
// FEATURE #19
: new PrimaryType(MetaData, PrimaryType.NullType));
// FEATURE #46
// FEATURE #47
if (retTypes.Count > 1)
{
var varName = $"retClctor{(ulong) GetHashCode()}";
Body.Statements.Insert(0, new VariableDeclaration(MetaData, varName, type: retType));
var returnValueCollector = new VariableExpression(MetaData, varName);
foreach (var endLabelStatement in EndLabel.StatementsUsingThis)
{
endLabelStatement.Unify(returnValueCollector);
}
Body.Statements.Add(new ReturnStatement(MetaData, returnValueCollector)
{
ReturnLabel = EndLabel
});
}
Type = new LambdaType(MetaData, (
from i in ParameterList
select i.Type).ToList(), retType);
}
