protected override Expression DoResolve (ResolveContext ec)
{
constructor_method = Delegate.GetConstructor (type);
var invoke_method = Delegate.GetInvokeMethod (type);
Arguments arguments = CreateDelegateMethodArguments (ec, invoke_method.Parameters, invoke_method.Parameters.Types, loc);
method_group = method_group.OverloadResolve (ec, ref arguments, this, OverloadResolver.Restrictions.CovariantDelegate);
if (method_group == null)
return null;
var delegate_method = method_group.BestCandidate;
if (delegate_method.DeclaringType.IsNullableType) {
ec.Report.Error (1728, loc, "Cannot create delegate from method `{0}' because it is a member of System.Nullable<T> type",
delegate_method.GetSignatureForError ());
return null;
}
if (!AllowSpecialMethodsInvocation)
Invocation.IsSpecialMethodInvocation (ec, delegate_method, loc);
ExtensionMethodGroupExpr emg = method_group as ExtensionMethodGroupExpr;
if (emg != null) {
method_group.InstanceExpression = emg.ExtensionExpression;
TypeSpec e_type = emg.ExtensionExpression.Type;
if (TypeSpec.IsValueType (e_type)) {
ec.Report.Error (1113, loc, "Extension method `{0}' of value type `{1}' cannot be used to create delegates",
delegate_method.GetSignatureForError (), e_type.GetSignatureForError ());
}
}
TypeSpec rt = delegate_method.ReturnType;
if (rt.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
rt = ec.BuiltinTypes.Object;
if (!Delegate.IsTypeCovariant (ec, rt, invoke_method.ReturnType)) {
Expression ret_expr = new TypeExpression (delegate_method.ReturnType, loc);
Error_ConversionFailed (ec, delegate_method, ret_expr);
}
if (delegate_method.IsConditionallyExcluded (ec, loc)) {
ec.Report.SymbolRelatedToPreviousError (delegate_method);
MethodOrOperator m = delegate_method.MemberDefinition as MethodOrOperator;
if (m != null && m.IsPartialDefinition) {
ec.Report.Error (762, loc, "Cannot create delegate from partial method declaration `{0}'",
delegate_method.GetSignatureForError ());
} else {
ec.Report.Error (1618, loc, "Cannot create delegate with `{0}' because it has a Conditional attribute",
TypeManager.CSharpSignature (delegate_method));
}
}
var expr = method_group.InstanceExpression;
if (expr != null && (expr.Type.IsGenericParameter || !TypeSpec.IsReferenceType (expr.Type)))
method_group.InstanceExpression = new BoxedCast (expr, ec.BuiltinTypes.Object);
eclass = ExprClass.Value;
return this;
}
public PartialMethodDefinitionInfo(MethodOrOperator mc)
{
this.mc = mc;
if ((mc.ModFlags & Modifiers.STATIC) != 0)
{
attrs = MethodAttributes.Static;
}
}
static CompiledMethod CompileBlock(Class host, Undo undo, Report Report)
{
AssemblyDefinitionDynamic assembly;
if (Environment.GetEnvironmentVariable("SAVE") != null)
{
assembly = new AssemblyDefinitionDynamic(RootContext.ToplevelTypes, current_debug_name, current_debug_name);
assembly.Importer = loader.Importer;
}
else
{
assembly = new AssemblyDefinitionDynamic(RootContext.ToplevelTypes, current_debug_name);
}
assembly.Create(AppDomain.CurrentDomain, AssemblyBuilderAccess.RunAndSave);
RootContext.ToplevelTypes.SetDeclaringAssembly(assembly);
RootContext.ToplevelTypes.Define();
if (Report.Errors != 0)
{
undo.ExecuteUndo();
return(null);
}
TypeBuilder tb = null;
MethodBuilder mb = null;
if (host != null)
{
tb = host.TypeBuilder;
mb = null;
foreach (MemberCore member in host.Methods)
{
if (member.Name != "Host")
{
continue;
}
MethodOrOperator method = (MethodOrOperator)member;
mb = method.MethodBuilder;
break;
}
if (mb == null)
{
throw new Exception("Internal error: did not find the method builder for the generated method");
}
}
RootContext.ToplevelTypes.Emit();
if (Report.Errors != 0)
{
undo.ExecuteUndo();
return(null);
}
RootContext.ToplevelTypes.CloseType();
if (Environment.GetEnvironmentVariable("SAVE") != null)
{
assembly.Save();
}
if (host == null)
{
return(null);
}
//
// Unlike Mono, .NET requires that the MethodInfo is fetched, it cant
// work from MethodBuilders. Retarded, I know.
//
var tt = assembly.Builder.GetType(tb.Name);
MethodInfo mi = tt.GetMethod(mb.Name);
// Pull the FieldInfos from the type, and keep track of them
foreach (Field field in queued_fields)
{
FieldInfo fi = tt.GetField(field.Name);
Tuple <FieldSpec, FieldInfo> old;
// If a previous value was set, nullify it, so that we do
// not leak memory
if (fields.TryGetValue(field.Name, out old))
{
if (old.Item1.MemberType.IsStruct)
{
//
// TODO: Clear fields for structs
//
}
else
{
try
{
old.Item2.SetValue(null, null);
}
catch
{
}
}
fields [field.Name] = Tuple.Create(field.Spec, fi);
}
else
{
fields.Add(field.Name, Tuple.Create(field.Spec, fi));
}
}
//types.Add (tb);
queued_fields.Clear();
return((CompiledMethod)System.Delegate.CreateDelegate(typeof(CompiledMethod), mi));
}
public static string [] GetCompletions(string input, out string prefix)
{
prefix = "";
if (input == null || input.Length == 0)
{
return(null);
}
lock (evaluator_lock)
{
if (!inited)
{
Init();
}
bool partial_input;
CSharpParser parser = ParseString(ParseMode.GetCompletions, input, out partial_input);
if (parser == null)
{
if (CSharpParser.yacc_verbose_flag != 0)
{
Console.WriteLine("DEBUG: No completions available");
}
return(null);
}
Class parser_result = parser.InteractiveResult as Class;
if (parser_result == null)
{
if (CSharpParser.yacc_verbose_flag != 0)
{
Console.WriteLine("Do not know how to cope with !Class yet");
}
return(null);
}
try
{
var a = new AssemblyDefinitionDynamic(RootContext.ToplevelTypes, "temp");
a.Create(AppDomain.CurrentDomain, AssemblyBuilderAccess.Run);
RootContext.ToplevelTypes.SetDeclaringAssembly(a);
RootContext.ToplevelTypes.Define();
if (ctx.Report.Errors != 0)
{
return(null);
}
MethodOrOperator method = null;
foreach (MemberCore member in parser_result.Methods)
{
if (member.Name != "Host")
{
continue;
}
method = (MethodOrOperator)member;
break;
}
if (method == null)
{
throw new InternalErrorException("did not find the the Host method");
}
BlockContext bc = new BlockContext(method, method.Block, method.ReturnType);
try
{
method.Block.Resolve(null, bc, method);
}
catch (CompletionResult cr)
{
prefix = cr.BaseText;
return(cr.Result);
}
}
finally
{
parser.undo.ExecuteUndo();
}
}
return(null);
}
public void AddMethod (MethodOrOperator method)
{
if (!AddToContainer (method, method.MemberName.Basename))
return;
if (methods == null)
methods = new List<MemberCore> ();
AddMemberToList (method, methods);
}
public void AddMethod (MethodOrOperator method)
{
orderedAllMembers.Add (method);
if (!AddToContainer (method, method.MemberName.Basename))
return;
if (methods == null)
methods = new List<MemberCore> ();
if (method.MemberName.Left != null)
AddMemberToList (method, methods, true);
else
AddMemberToList (method, methods, false);
}
public override Expression DoResolve(ResolveContext ec)
{
constructor_method = Delegate.GetConstructor(ec.Compiler, ec.CurrentType, type);
MethodInfo invoke_method = Delegate.GetInvokeMethod(ec.Compiler, ec.CurrentType, type);
method_group.DelegateType = type;
method_group.CustomErrorHandler = this;
Arguments arguments = CreateDelegateMethodArguments(TypeManager.GetParameterData(invoke_method), loc);
method_group = method_group.OverloadResolve(ec, ref arguments, false, loc);
if (method_group == null)
{
return(null);
}
delegate_method = (MethodInfo)method_group;
if (TypeManager.IsNullableType(delegate_method.DeclaringType))
{
ec.Report.Error(1728, loc, "Cannot create delegate from method `{0}' because it is a member of System.Nullable<T> type",
TypeManager.GetFullNameSignature(delegate_method));
return(null);
}
Invocation.IsSpecialMethodInvocation(ec, delegate_method, loc);
ExtensionMethodGroupExpr emg = method_group as ExtensionMethodGroupExpr;
if (emg != null)
{
delegate_instance_expression = emg.ExtensionExpression;
Type e_type = delegate_instance_expression.Type;
if (TypeManager.IsValueType(e_type))
{
ec.Report.Error(1113, loc, "Extension method `{0}' of value type `{1}' cannot be used to create delegates",
TypeManager.CSharpSignature(delegate_method), TypeManager.CSharpName(e_type));
}
}
Type rt = TypeManager.TypeToCoreType(delegate_method.ReturnType);
Expression ret_expr = new TypeExpression(rt, loc);
if (!Delegate.IsTypeCovariant(ret_expr, (TypeManager.TypeToCoreType(invoke_method.ReturnType))))
{
Error_ConversionFailed(ec, delegate_method, ret_expr);
}
if (Invocation.IsMethodExcluded(delegate_method, loc))
{
ec.Report.SymbolRelatedToPreviousError(delegate_method);
MethodOrOperator m = TypeManager.GetMethod(delegate_method) as MethodOrOperator;
if (m != null && m.IsPartialDefinition)
{
ec.Report.Error(762, loc, "Cannot create delegate from partial method declaration `{0}'",
TypeManager.CSharpSignature(delegate_method));
}
else
{
ec.Report.Error(1618, loc, "Cannot create delegate with `{0}' because it has a Conditional attribute",
TypeManager.CSharpSignature(delegate_method));
}
}
DoResolveInstanceExpression(ec);
eclass = ExprClass.Value;
return(this);
}
static CompiledMethod CompileBlock(Class host, Undo undo)
{
RootContext.ResolveTree();
if (Report.Errors != 0)
{
undo.ExecuteUndo();
return(null);
}
RootContext.PopulateTypes();
if (Report.Errors != 0)
{
undo.ExecuteUndo();
return(null);
}
TypeBuilder tb = null;
MethodBuilder mb = null;
if (host != null)
{
tb = host.TypeBuilder;
mb = null;
foreach (MemberCore member in host.Methods)
{
if (member.Name != "Host")
{
continue;
}
MethodOrOperator method = (MethodOrOperator)member;
mb = method.MethodBuilder;
break;
}
if (mb == null)
{
throw new Exception("Internal error: did not find the method builder for the generated method");
}
}
RootContext.EmitCode();
if (Report.Errors != 0)
{
return(null);
}
RootContext.CloseTypes();
if (Environment.GetEnvironmentVariable("SAVE") != null)
{
CodeGen.Save(current_debug_name, false);
}
if (host == null)
{
return(null);
}
//
// Unlike Mono, .NET requires that the MethodInfo is fetched, it cant
// work from MethodBuilders. Retarded, I know.
//
Type tt = CodeGen.Assembly.Builder.GetType(tb.Name);
MethodInfo mi = tt.GetMethod(mb.Name);
// Pull the FieldInfos from the type, and keep track of them
foreach (Field field in queued_fields)
{
FieldInfo fi = tt.GetField(field.Name);
FieldInfo old = (FieldInfo)fields [field.Name];
// If a previous value was set, nullify it, so that we do
// not leak memory
if (old != null)
{
if (old.FieldType.IsValueType)
{
//
// TODO: Clear fields for structs
//
}
else
{
try {
old.SetValue(null, null);
} catch {
}
}
}
fields [field.Name] = fi;
}
//types.Add (tb);
queued_fields.Clear();
return((CompiledMethod)System.Delegate.CreateDelegate(typeof(CompiledMethod), mi));
}
public PartialMethodDefinitionInfo (MethodOrOperator mc)
{
this.mc = mc;
if ((mc.ModFlags & Modifiers.STATIC) != 0)
attrs = MethodAttributes.Static;
}
/// <summary>
/// Define and resolve the type parameters.
/// We're called from Method.Define().
/// </summary>
public bool Define (MethodOrOperator m)
{
TypeParameterName[] names = MemberName.TypeArguments.GetDeclarations ();
string[] snames = new string [names.Length];
for (int i = 0; i < names.Length; i++) {
string type_argument_name = names[i].Name;
int idx = parameters.GetParameterIndexByName (type_argument_name);
if (idx >= 0) {
Block b = m.Block;
if (b == null)
b = new Block (null);
b.Error_AlreadyDeclaredTypeParameter (parameters [i].Location,
type_argument_name, "method parameter");
}
snames[i] = type_argument_name;
}
GenericTypeParameterBuilder[] gen_params = m.MethodBuilder.DefineGenericParameters (snames);
for (int i = 0; i < TypeParameters.Length; i++)
TypeParameters [i].Define (gen_params [i]);
if (!Define ())
return false;
for (int i = 0; i < TypeParameters.Length; i++) {
if (!TypeParameters [i].ResolveType (this))
return false;
}
return true;
}
public void RemoveMethod(MethodOrOperator method){
RemoveFromContainer(method.Name);
RemoveFromMemberList(method,methods);
}
/// <summary>
/// Define and resolve the type parameters.
/// We're called from Method.Define().
/// </summary>
public bool Define (MethodOrOperator m)
{
TypeParameterName[] names = MemberName.TypeArguments.GetDeclarations ();
string[] snames = new string [names.Length];
for (int i = 0; i < names.Length; i++) {
string type_argument_name = names[i].Name;
int idx = parameters.GetParameterIndexByName (type_argument_name);
if (idx >= 0) {
var b = m.Block;
if (b == null)
b = new ToplevelBlock (Compiler, Location);
b.Error_AlreadyDeclaredTypeParameter (parameters [i].Location,
type_argument_name, "method parameter");
}
if (m.Block != null) {
var ikv = m.Block.GetKnownVariable (type_argument_name);
if (ikv != null)
ikv.Block.Error_AlreadyDeclaredTypeParameter (ikv.Location, type_argument_name, "local variable");
}
snames[i] = type_argument_name;
}
GenericTypeParameterBuilder[] gen_params = m.MethodBuilder.DefineGenericParameters (snames);
for (int i = 0; i < TypeParameters.Length; i++)
TypeParameters [i].Define (gen_params [i], null);
return true;
}
public void AddMethod (MethodOrOperator method)
{
if (!AddToContainer (method, method.MemberName.Basename))
return;
if (methods == null)
methods = new MemberCoreArrayList ();
if (method.MemberName.Left != null)
AddMemberToList (method, methods, true);
else
AddMemberToList (method, methods, false);
}