private HybInstance CreateInstanceInterpretType(Runner runner, HybInstance[] args,
object parentObject = null)
{
var inst = new HybInstance(runner, this, InterpretKlass, parentObject);
var ctors = GetMethods("$_ctor");
if (ctors.Length > 0)
{
var ctor = OverloadingResolver
.FindMethodWithArguments(runner.Resolver, ctors, new HybType[] { }, ref args);
ctor.Target.Invoke(inst, args);
}
return(inst);
}
private void ProcessArrayInitializer(HybInstance inst, InitializerExpressionSyntax init)
{
var addMethods = inst.GetMethods("Add");
foreach (var expr in init.Expressions)
{
if (expr is AssignmentExpressionSyntax)
{
throw new SemanticViolationException("");
}
var value = RunExpression(expr);
var addArgs = new HybInstance[] { value };
var method = OverloadingResolver.FindMethodWithArguments(
Resolver, addMethods, new HybType[] { }, ref addArgs);
method.Target.Invoke(inst, addArgs);
}
}
public HybInstance Invoke(string name, params object[] args)
{
var wrappedArgs = args.Wrap();
var methods = GetMethods(name);
if (methods.Length == 0)
{
throw new ArgumentException($"No such method: {name}");
}
var method = OverloadingResolver.FindMethodWithArguments(
Runner.Resolver, methods, new HybType[] { }, ref wrappedArgs);
if (method == null)
{
throw new ArgumentException($"No matching override found: {name}");
}
if (method.DeclaringType == Type)
{
return(method.Target.Invoke(this, wrappedArgs));
}
return(method.Target.Invoke(Parent, wrappedArgs));
}
private void ProcessInitializer(HybInstance inst, InitializerExpressionSyntax init)
{
if (IsDictionaryAddible(inst, init))
{
var setMethod = inst.GetSetIndexerMethod();
foreach (var expr in init.Expressions)
{
if (expr is AssignmentExpressionSyntax assign)
{
var right = RunExpression(assign.Right);
if (assign.Left is ImplicitElementAccessSyntax ea)
{
var args = new HybInstance[ea.ArgumentList.Arguments.Count];
var count = 0;
foreach (var arg in ea.ArgumentList.Arguments)
{
args[count++] = RunExpression(arg.Expression);
}
inst.SetIndexer(args, right);
}
}
else if (expr is InitializerExpressionSyntax initializer)
{
var left = RunExpression(initializer.Expressions[0]);
var right = RunExpression(initializer.Expressions[1]);
inst.SetIndexer(new HybInstance[] { left }, right);
}
else
{
throw new SemanticViolationException("");
}
}
}
else if (IsArrayAddible(inst))
{
var addMethods = inst.GetMethods("Add");
foreach (var expr in init.Expressions)
{
if (expr is AssignmentExpressionSyntax)
{
throw new SemanticViolationException("");
}
var value = RunExpression(expr);
var addArgs = new HybInstance[] { value };
var method = OverloadingResolver.FindMethodWithArguments(
Resolver, addMethods, new HybType[] { }, ref addArgs);
method.Target.Invoke(inst, addArgs);
}
}
else
{
foreach (var expr in init.Expressions)
{
if (expr is AssignmentExpressionSyntax assign)
{
var id = (IdentifierNameSyntax)assign.Left;
var value = RunExpression(assign.Right);
if (inst.SetPropertyOrField($"{id.Identifier}", value) == false)
{
throw new SemanticViolationException($"No such member: {id}");
}
}
else
{
throw new SemanticViolationException("");
}
}
}
}
/// <summary>
/// Runs invocation expression.
/// [Syntax] Console.WriteLine("Hello World");
/// Foo(1234);
/// </summary>
private HybInstance RunInvocation(InvocationExpressionSyntax node)
{
string calleeId = "";
string targetId = "";
HybInstance callee = null;
SSMethodInfo[] callsite = null;
HybType[] implicitGenericArgs = null;
var(args, hasRefOrOut) = ResolveArgumentList(node.ArgumentList);
if (node.Expression is MemberAccessExpressionSyntax ma)
{
var leftIsType = false;
var rightName = $"{ma.Name.Identifier}";
implicitGenericArgs = ResolveGenericArgumentsFromName(ma.Name);
if (ma.Expression is PredefinedTypeSyntax pd)
{
HybType leftType = null;
leftIsType = true;
leftType = Resolver.GetType($"{pd}");
callsite = leftType.GetStaticMethods(rightName);
}
else if (ma.Expression is IdentifierNameSyntax id)
{
HybType leftType = null;
if (Resolver.TryGetType($"{id.Identifier}", out leftType))
{
leftIsType = true;
callsite = leftType.GetStaticMethods(rightName);
}
else
{
callee = ResolveId(id);
callsite = callee.GetMethods(rightName);
}
calleeId = $"{id.Identifier}";
}
else if (ma.Expression is ExpressionSyntax expr)
{
callee = RunExpression(expr);
callsite = callee.GetMethods($"{ma.Name}");
}
if (leftIsType == false &&
callsite.Length == 0)
{
callsite = ExtResolver.GetCallablegExtensions(callee, $"{ma.Name}");
args = (new HybInstance[] { callee }).Concat(args).ToArray();
}
targetId = $"{ma.Name}";
//callsite = ResolveMemberAccess(node.Expression as MemberAccessExpressionSyntax);
}
else if (node.Expression is SimpleNameSyntax ||
node.Expression is MemberBindingExpressionSyntax)
{
SimpleNameSyntax id = node.Expression as SimpleNameSyntax;
if (id == null)
{
id = (node.Expression as MemberBindingExpressionSyntax)?.Name;
callee = Ctx._bound;
}
else
{
callee = Ctx._this;
}
implicitGenericArgs = ResolveGenericArgumentsFromName(id);
callsite =
ResolveLocalMember(id)
.Concat(Ctx.Method.DeclaringType.GetStaticMethods(id.Identifier.Text))
.ToArray();
targetId = id.Identifier.Text;
}
if (callsite.Length == 0)
{
throw new NoSuchMethodException($"{calleeId}", targetId);
}
var method = OverloadingResolver.FindMethodWithArguments(
Resolver,
callsite,
implicitGenericArgs.ToArray(),
ref args);
if (method == null)
{
throw new SemanticViolationException($"No matching override for `{targetId}`");
}
if (callee != null && method.DeclaringType.Parent == callee.GetHybType())
{
callee = callee.Parent;
}
var ret = method.Target.Invoke(callee, args, hasRefOrOut);
// post-invoke
if (hasRefOrOut)
{
var count = 0;
foreach (var arg in node.ArgumentList.Arguments)
{
if (arg.RefKindKeyword != null)
{
RunAssign(arg.Expression, args[count]);
}
count++;
}
}
return(ret);
}
