|
public LookupType ( |
||
| ctx | ||
| name | string | |
| arity | int | |
| silent | bool | |
| loc | Mono.CSharp.Location | |
| Résultat | Mono.CSharp.TypeExpr | |
public static TypeSpec Resolve(ModuleContainer module, MemberKind kind, string ns, string name, int arity, Location loc)
{
Namespace type_ns = module.GlobalRootNamespace.GetNamespace(ns, true);
var te = type_ns.LookupType(module, name, arity, false, Location.Null);
if (te == null)
{
module.Compiler.Report.Error(518, loc, "The predefined type `{0}.{1}' is not defined or imported", ns, name);
return(null);
}
var type = te.Type;
if (type.Kind != kind)
{
if (type.Kind == MemberKind.Struct && kind == MemberKind.Void && type.MemberDefinition is TypeContainer)
{
// Void is declared as struct but we keep it internally as
// special kind, the swap will be done by caller
}
else
{
module.Compiler.Report.Error(520, loc, "The predefined type `{0}.{1}' is not declared correctly", ns, name);
return(null);
}
}
return(type);
}
public static TypeSpec CreateDelegateType(ResolveContext rc, AParametersCollection parameters, TypeSpec returnType, Location loc)
{
Namespace type_ns = rc.Module.GlobalRootNamespace.GetNamespace("System", true);
if (type_ns == null)
{
return(null);
}
if (returnType == rc.BuiltinTypes.Void)
{
var actArgs = parameters.Types;
var actionSpec = type_ns.LookupType(rc.Module, "Action", actArgs.Length, LookupMode.Normal, loc).ResolveAsType(rc);
if (actionSpec == null)
{
return(null);
}
if (actArgs.Length == 0)
{
return(actionSpec);
}
else
{
return(actionSpec.MakeGenericType(rc, actArgs));
}
}
else
{
TypeSpec[] funcArgs = new TypeSpec[parameters.Types.Length + 1];
parameters.Types.CopyTo(funcArgs, 0);
funcArgs[parameters.Types.Length] = returnType;
var funcSpec = type_ns.LookupType(rc.Module, "Func", funcArgs.Length, LookupMode.Normal, loc).ResolveAsType(rc);
if (funcSpec == null)
{
return(null);
}
return(funcSpec.MakeGenericType(rc, funcArgs));
}
}
public bool Define()
{
if (type != null)
{
return(true);
}
Namespace type_ns = module.GlobalRootNamespace.GetNamespace(ns, true);
var te = type_ns.LookupType(module, name, arity, true, Location.Null);
if (te == null || te.Type.Kind != kind)
{
return(false);
}
type = te.Type;
return(true);
}
public static TypeSpec Resolve(ModuleContainer module, MemberKind kind, string ns, string name, int arity, Location loc)
{
Namespace type_ns = module.GlobalRootNamespace.GetNamespace(ns, true);
var te = type_ns.LookupType(module.Compiler, name, arity, false, Location.Null);
if (te == null)
{
module.Compiler.Report.Error(518, loc, "The predefined type `{0}.{1}' is not defined or imported", ns, name);
return(null);
}
var type = te.Type;
if (type.Kind != kind)
{
module.Compiler.Report.Error(520, loc, "The predefined type `{0}.{1}' is not declared correctly", ns, name);
return(null);
}
return(type);
}
protected void EmitCall(EmitContext ec, Expression binder, Arguments arguments, bool isStatement)
{
//
// This method generates all internal infrastructure for a dynamic call. The
// reason why it's quite complicated is the mixture of dynamic and anonymous
// methods. Dynamic itself requires a temporary class (ContainerX) and anonymous
// methods can generate temporary storey as well (AnonStorey). Handling MVAR
// type parameters rewrite is non-trivial in such case as there are various
// combinations possible therefore the mutator is not straightforward. Secondly
// we need to keep both MVAR(possibly VAR for anon storey) and type VAR to emit
// correct Site field type and its access from EmitContext.
//
int dyn_args_count = arguments == null ? 0 : arguments.Count;
int default_args = isStatement ? 1 : 2;
var module = ec.Module;
bool has_ref_out_argument = false;
var targs = new TypeExpression[dyn_args_count + default_args];
targs[0] = new TypeExpression(module.PredefinedTypes.CallSite.TypeSpec, loc);
TypeExpression[] targs_for_instance = null;
TypeParameterMutator mutator;
var site_container = ec.CreateDynamicSite();
if (context_mvars != null)
{
TypeParameters tparam;
TypeContainer sc = site_container;
do
{
tparam = sc.CurrentTypeParameters;
sc = sc.Parent;
} while (tparam == null);
mutator = new TypeParameterMutator(context_mvars, tparam);
if (!ec.IsAnonymousStoreyMutateRequired)
{
targs_for_instance = new TypeExpression[targs.Length];
targs_for_instance[0] = targs[0];
}
}
else
{
mutator = null;
}
for (int i = 0; i < dyn_args_count; ++i)
{
Argument a = arguments[i];
if (a.ArgType == Argument.AType.Out || a.ArgType == Argument.AType.Ref)
{
has_ref_out_argument = true;
}
var t = a.Type;
// Convert any internal type like dynamic or null to object
if (t.Kind == MemberKind.InternalCompilerType)
{
t = ec.BuiltinTypes.Object;
}
if (targs_for_instance != null)
{
targs_for_instance[i + 1] = new TypeExpression(t, loc);
}
if (mutator != null)
{
t = t.Mutate(mutator);
}
targs[i + 1] = new TypeExpression(t, loc);
}
TypeExpr del_type = null;
TypeExpr del_type_instance_access = null;
if (!has_ref_out_argument)
{
string d_name = isStatement ? "Action" : "Func";
TypeSpec te = null;
Namespace type_ns = module.GlobalRootNamespace.GetNamespace("System", true);
if (type_ns != null)
{
te = type_ns.LookupType(module, d_name, dyn_args_count + default_args, LookupMode.Normal, loc);
}
if (te != null)
{
if (!isStatement)
{
var t = type;
if (t.Kind == MemberKind.InternalCompilerType)
{
t = ec.BuiltinTypes.Object;
}
if (targs_for_instance != null)
{
targs_for_instance[targs_for_instance.Length - 1] = new TypeExpression(t, loc);
}
if (mutator != null)
{
t = t.Mutate(mutator);
}
targs[targs.Length - 1] = new TypeExpression(t, loc);
}
del_type = new GenericTypeExpr(te, new TypeArguments(targs), loc);
if (targs_for_instance != null)
{
del_type_instance_access = new GenericTypeExpr(te, new TypeArguments(targs_for_instance), loc);
}
else
{
del_type_instance_access = del_type;
}
}
}
//
// Create custom delegate when no appropriate predefined delegate has been found
//
Delegate d;
if (del_type == null)
{
TypeSpec rt = isStatement ? ec.BuiltinTypes.Void : type;
Parameter[] p = new Parameter[dyn_args_count + 1];
p[0] = new Parameter(targs[0], "p0", Parameter.Modifier.NONE, null, loc);
var site = ec.CreateDynamicSite();
int index = site.Containers == null ? 0 : site.Containers.Count;
if (mutator != null)
{
rt = mutator.Mutate(rt);
}
for (int i = 1; i < dyn_args_count + 1; ++i)
{
p[i] = new Parameter(targs[i], "p" + i.ToString("X"), arguments[i - 1].Modifier, null, loc);
}
d = new Delegate(site, new TypeExpression(rt, loc),
Modifiers.INTERNAL | Modifiers.COMPILER_GENERATED,
new MemberName("Container" + index.ToString("X")),
new ParametersCompiled(p), null);
d.CreateContainer();
d.DefineContainer();
d.Define();
d.PrepareEmit();
site.AddTypeContainer(d);
//
// Add new container to inflated site container when the
// member cache already exists
//
if (site.CurrentType is InflatedTypeSpec && index > 0)
{
site.CurrentType.MemberCache.AddMember(d.CurrentType);
}
del_type = new TypeExpression(d.CurrentType, loc);
if (targs_for_instance != null)
{
del_type_instance_access = null;
}
else
{
del_type_instance_access = del_type;
}
}
else
{
d = null;
}
var site_type_decl = new GenericTypeExpr(module.PredefinedTypes.CallSiteGeneric.TypeSpec, new TypeArguments(del_type), loc);
var field = site_container.CreateCallSiteField(site_type_decl, loc);
if (field == null)
{
return;
}
if (del_type_instance_access == null)
{
var dt = d.CurrentType.DeclaringType.MakeGenericType(module, context_mvars.Types);
del_type_instance_access = new TypeExpression(MemberCache.GetMember(dt, d.CurrentType), loc);
}
var instanceAccessExprType = new GenericTypeExpr(module.PredefinedTypes.CallSiteGeneric.TypeSpec,
new TypeArguments(del_type_instance_access), loc);
if (instanceAccessExprType.ResolveAsType(ec.MemberContext) == null)
{
return;
}
bool inflate_using_mvar = context_mvars != null && ec.IsAnonymousStoreyMutateRequired;
TypeSpec gt;
if (inflate_using_mvar || context_mvars == null)
{
gt = site_container.CurrentType;
}
else
{
gt = site_container.CurrentType.MakeGenericType(module, context_mvars.Types);
}
// When site container already exists the inflated version has to be
// updated manually to contain newly created field
if (gt is InflatedTypeSpec && site_container.AnonymousMethodsCounter > 1)
{
var tparams = gt.MemberDefinition.TypeParametersCount > 0 ? gt.MemberDefinition.TypeParameters : TypeParameterSpec.EmptyTypes;
var inflator = new TypeParameterInflator(module, gt, tparams, gt.TypeArguments);
gt.MemberCache.AddMember(field.InflateMember(inflator));
}
FieldExpr site_field_expr = new FieldExpr(MemberCache.GetMember(gt, field), loc);
BlockContext bc = new BlockContext(ec.MemberContext, null, ec.BuiltinTypes.Void);
Arguments args = new Arguments(1);
args.Add(new Argument(binder));
StatementExpression s = new StatementExpression(new SimpleAssign(site_field_expr, new Invocation(new MemberAccess(instanceAccessExprType, "Create"), args)));
using (ec.With(BuilderContext.Options.OmitDebugInfo, true)) {
if (s.Resolve(bc))
{
Statement init = new If(new Binary(Binary.Operator.Equality, site_field_expr, new NullLiteral(loc)), s, loc);
init.Emit(ec);
}
args = new Arguments(1 + dyn_args_count);
args.Add(new Argument(site_field_expr));
if (arguments != null)
{
int arg_pos = 1;
foreach (Argument a in arguments)
{
if (a is NamedArgument)
{
// Name is not valid in this context
args.Add(new Argument(a.Expr, a.ArgType));
}
else
{
args.Add(a);
}
if (inflate_using_mvar && a.Type != targs[arg_pos].Type)
{
a.Expr.Type = targs[arg_pos].Type;
}
++arg_pos;
}
}
Expression target = new DelegateInvocation(new MemberAccess(site_field_expr, "Target", loc).Resolve(bc), args, loc).Resolve(bc);
if (target != null)
{
target.Emit(ec);
}
}
}
private static TypeSpec FindDocumentedTypeNonArray(MemberCore mc,
string identifier, DeclSpace ds, string cref, Report r)
{
switch (identifier)
{
case "int":
return(TypeManager.int32_type);
case "uint":
return(TypeManager.uint32_type);
case "short":
return(TypeManager.short_type);;
case "ushort":
return(TypeManager.ushort_type);
case "long":
return(TypeManager.int64_type);
case "ulong":
return(TypeManager.uint64_type);;
case "float":
return(TypeManager.float_type);;
case "double":
return(TypeManager.double_type);
case "char":
return(TypeManager.char_type);;
case "decimal":
return(TypeManager.decimal_type);;
case "byte":
return(TypeManager.byte_type);;
case "sbyte":
return(TypeManager.sbyte_type);;
case "object":
return(TypeManager.object_type);;
case "bool":
return(TypeManager.bool_type);;
case "string":
return(TypeManager.string_type);;
case "void":
return(TypeManager.void_type);;
}
FullNamedExpression e = ds.LookupNamespaceOrType(identifier, 0, mc.Location, false);
if (e != null)
{
if (!(e is TypeExpr))
{
return(null);
}
return(e.Type);
}
int index = identifier.LastIndexOf('.');
if (index < 0)
{
return(null);
}
var nsName = identifier.Substring(0, index);
var typeName = identifier.Substring(index + 1);
Namespace ns = ds.NamespaceEntry.NS.GetNamespace(nsName, false);
ns = ns ?? mc.Module.GlobalRootNamespace.GetNamespace(nsName, false);
if (ns != null)
{
var te = ns.LookupType(mc.Compiler, typeName, 0, true, mc.Location);
if (te != null)
{
return(te.Type);
}
}
int warn;
TypeSpec parent = FindDocumentedType(mc, identifier.Substring(0, index), ds, cref, r);
if (parent == null)
{
return(null);
}
// no need to detect warning 419 here
var ts = FindDocumentedMember(mc, parent,
identifier.Substring(index + 1),
null, ds, out warn, cref, false, null, r) as TypeSpec;
if (ts != null)
{
return(ts);
}
return(null);
}
private static TypeSpec FindDocumentedTypeNonArray(MemberCore mc,
string identifier, DeclSpace ds, string cref, Report r)
{
var types = mc.Module.Compiler.BuiltinTypes;
switch (identifier)
{
case "int":
return(types.Int);
case "uint":
return(types.UInt);
case "short":
return(types.Short);
case "ushort":
return(types.UShort);
case "long":
return(types.Long);
case "ulong":
return(types.ULong);
case "float":
return(types.Float);
case "double":
return(types.Double);
case "char":
return(types.Char);
case "decimal":
return(types.Decimal);
case "byte":
return(types.Byte);
case "sbyte":
return(types.SByte);
case "object":
return(types.Object);
case "bool":
return(types.Bool);
case "string":
return(types.String);
case "void":
return(types.Void);
}
FullNamedExpression e = ds.LookupNamespaceOrType(identifier, 0, mc.Location, false);
if (e != null)
{
if (!(e is TypeExpr))
{
return(null);
}
return(e.Type);
}
int index = identifier.LastIndexOf('.');
if (index < 0)
{
return(null);
}
var nsName = identifier.Substring(0, index);
var typeName = identifier.Substring(index + 1);
Namespace ns = ds.NamespaceEntry.NS.GetNamespace(nsName, false);
ns = ns ?? mc.Module.GlobalRootNamespace.GetNamespace(nsName, false);
if (ns != null)
{
var te = ns.LookupType(mc, typeName, 0, true, mc.Location);
if (te != null)
{
return(te.Type);
}
}
int warn;
TypeSpec parent = FindDocumentedType(mc, identifier.Substring(0, index), ds, cref, r);
if (parent == null)
{
return(null);
}
// no need to detect warning 419 here
var ts = FindDocumentedMember(mc, parent,
identifier.Substring(index + 1),
null, ds, out warn, cref, false, null, r) as TypeSpec;
if (ts != null)
{
return(ts);
}
return(null);
}
TypeExpr CreateSiteType(EmitContext ec, Arguments arguments, int dyn_args_count, bool is_statement)
{
int default_args = is_statement ? 1 : 2;
var module = ec.MemberContext.Module;
bool has_ref_out_argument = false;
var targs = new TypeExpression[dyn_args_count + default_args];
targs [0] = new TypeExpression(module.PredefinedTypes.CallSite.TypeSpec, loc);
for (int i = 0; i < dyn_args_count; ++i)
{
Argument a = arguments [i];
if (a.ArgType == Argument.AType.Out || a.ArgType == Argument.AType.Ref)
{
has_ref_out_argument = true;
}
var t = a.Type;
// Convert any internal type like dynamic or null to object
if (t.Kind == MemberKind.InternalCompilerType)
{
t = TypeManager.object_type;
}
targs [i + 1] = new TypeExpression(t, loc);
}
TypeExpr del_type = null;
if (!has_ref_out_argument)
{
string d_name = is_statement ? "Action" : "Func";
TypeExpr te = null;
Namespace type_ns = module.GlobalRootNamespace.GetNamespace("System", true);
if (type_ns != null)
{
te = type_ns.LookupType(module.Compiler, d_name, dyn_args_count + default_args, true, Location.Null);
}
if (te != null)
{
if (!is_statement)
{
targs [targs.Length - 1] = new TypeExpression(type, loc);
}
del_type = new GenericTypeExpr(te.Type, new TypeArguments(targs), loc);
}
}
//
// Create custom delegate when no appropriate predefined one is found
//
if (del_type == null)
{
TypeSpec rt = is_statement ? TypeManager.void_type : type;
Parameter[] p = new Parameter [dyn_args_count + 1];
p[0] = new Parameter(targs [0], "p0", Parameter.Modifier.NONE, null, loc);
var site = ec.CreateDynamicSite();
int index = site.Types == null ? 0 : site.Types.Count;
if (site.Mutator != null)
{
rt = site.Mutator.Mutate(rt);
}
for (int i = 1; i < dyn_args_count + 1; ++i)
{
var t = targs[i];
if (site.Mutator != null)
{
t.Type = site.Mutator.Mutate(t.Type);
}
p[i] = new Parameter(t, "p" + i.ToString("X"), arguments[i - 1].Modifier, null, loc);
}
Delegate d = new Delegate(site.NamespaceEntry, site, new TypeExpression(rt, loc),
Modifiers.INTERNAL | Modifiers.COMPILER_GENERATED,
new MemberName("Container" + index.ToString("X")),
new ParametersCompiled(p), null);
d.CreateType();
d.DefineType();
d.Define();
d.Emit();
var inflated = site.AddDelegate(d);
del_type = new TypeExpression(inflated, loc);
}
TypeExpr site_type = new GenericTypeExpr(module.PredefinedTypes.CallSiteGeneric.TypeSpec, new TypeArguments(del_type), loc);
return(site_type);
}
