storey_type_expr = new TypeExpression (TypeBuilder, Location);
}
- Expression e = new New (storey_type_expr, new ArrayList (0), Location).Resolve (ec);
+ Expression e = new New (storey_type_expr, null, Location).Resolve (ec);
e.Emit (ec);
Instance = new LocalTemporary (storey_type_expr.Type);
Type t = MutateGenericType (method.DeclaringType);
if (t != method.DeclaringType) {
method = (MethodInfo) TypeManager.DropGenericMethodArguments (method);
- if (method.Module == CodeGen.Module.Builder)
+ if (method.Module == Module.Builder)
method = TypeBuilder.GetMethod (t, method);
else
method = (MethodInfo) MethodInfo.GetMethodFromHandle (method.MethodHandle, t.TypeHandle);
Type t = MutateGenericType (ctor.DeclaringType);
if (t != ctor.DeclaringType) {
ctor = (ConstructorInfo) TypeManager.DropGenericMethodArguments (ctor);
- if (ctor.Module == CodeGen.Module.Builder)
+ if (ctor.Module == Module.Builder)
return TypeBuilder.GetConstructor (t, ctor);
return (ConstructorInfo) ConstructorInfo.GetMethodFromHandle (ctor.MethodHandle, t.TypeHandle);
if (TypeManager.IsGenericType (field.DeclaringType)) {
Type t = MutateGenericType (field.DeclaringType);
if (t != field.DeclaringType) {
- // TODO: It should throw on imported types
- return TypeBuilder.GetField (t, field);
+ field = TypeManager.DropGenericTypeArguments (field.DeclaringType).GetField (field.Name, TypeManager.AllMembers);
+ if (field.Module == Module.Builder)
+ return TypeBuilder.GetField (t, field);
+
+ return FieldInfo.GetFieldFromHandle (field.FieldHandle, t.TypeHandle);
}
}
#endif
#if GMCS_SOURCE
protected Type MutateArrayType (Type array)
{
- int rank = array.GetArrayRank ();
Type element = TypeManager.GetElementType (array);
- if (element.IsArray)
- throw new NotImplementedException ();
-
- if (TypeManager.IsGenericParameter (element)) {
+ if (element.IsArray) {
+ element = MutateArrayType (element);
+ } else if (TypeManager.IsGenericParameter (element)) {
element = MutateGenericArgument (element);
} else if (TypeManager.IsGenericType (element)) {
element = MutateGenericType (element);
return array;
}
+ int rank = array.GetArrayRank ();
+ if (rank == 1)
+ return element.MakeArrayType ();
+
return element.MakeArrayType (rank);
}
for (int i = 0; i < t_args.Length; ++i)
t_args [i] = MutateType (t_args [i]);
- return type.GetGenericTypeDefinition ().MakeGenericType (t_args);
+ return TypeManager.DropGenericTypeArguments (type).MakeGenericType (t_args);
}
#endif
}
if (inner_access == null) {
- inner_access = new FieldExpr (field.FieldBuilder, field.Location);
+ inner_access = field.Parent.MemberName.IsGeneric ?
+ new FieldExpr (field.FieldBuilder, field.Parent.CurrentType, field.Location) :
+ new FieldExpr (field.FieldBuilder, field.Location);
+
inner_access.InstanceExpression = storey.GetStoreyInstanceExpression (ec);
inner_access.Resolve (ec);
cached_inner_access.Add (ec.CurrentAnonymousMethod, inner_access);
public virtual bool HasExplicitParameters {
get {
- return Parameters != Parameters.Undefined;
+ return Parameters != ParametersCompiled.Undefined;
}
}
- public Parameters Parameters {
+ public ParametersCompiled Parameters {
get { return Block.Parameters; }
}
//
public bool ImplicitStandardConversionExists (EmitContext ec, Type delegate_type)
{
- using (ec.Set (EmitContext.Flags.ProbingMode)) {
- return Compatible (ec, delegate_type) != null;
+ using (ec.With (EmitContext.Flags.InferReturnType, false)) {
+ using (ec.Set (EmitContext.Flags.ProbingMode)) {
+ return Compatible (ec, delegate_type) != null;
+ }
}
}
if (TypeManager.IsDelegateType (delegate_type))
return delegate_type;
-#if GMCS_SOURCE
if (TypeManager.DropGenericTypeArguments (delegate_type) == TypeManager.expression_type) {
delegate_type = TypeManager.GetTypeArguments (delegate_type) [0];
if (TypeManager.IsDelegateType (delegate_type))
GetSignatureForError (), TypeManager.CSharpName (delegate_type));
return null;
}
-#endif
Report.Error (1660, loc, "Cannot convert `{0}' to non-delegate type `{1}'",
GetSignatureForError (), TypeManager.CSharpName (delegate_type));
return false;
if (!TypeManager.IsDelegateType (delegate_type)) {
-#if GMCS_SOURCE
if (TypeManager.DropGenericTypeArguments (delegate_type) != TypeManager.expression_type)
return false;
- delegate_type = delegate_type.GetGenericArguments () [0];
+ delegate_type = TypeManager.GetTypeArguments (delegate_type) [0];
if (!TypeManager.IsDelegateType (delegate_type))
return false;
-#else
- return false;
-#endif
}
AParametersCollection d_params = TypeManager.GetDelegateParameters (delegate_type);
{
AnonymousMethodBody am;
using (ec.Set (EmitContext.Flags.ProbingMode | EmitContext.Flags.InferReturnType)) {
- am = CompatibleMethod (ec, tic, GetType (), delegate_type);
+ am = CompatibleMethod (ec, tic, InternalType.Arglist, delegate_type);
}
if (am == null)
return null;
- if (am.ReturnType == TypeManager.null_type)
- am.ReturnType = null;
-
return am.ReturnType;
}
compatibles.Add (type, am == null ? EmptyExpression.Null : am);
return am;
+ } catch (CompletionResult){
+ throw;
} catch (Exception e) {
throw new InternalErrorException (e, loc);
}
return null;
}
- protected virtual Parameters ResolveParameters (EmitContext ec, TypeInferenceContext tic, Type delegate_type)
+ protected virtual ParametersCompiled ResolveParameters (EmitContext ec, TypeInferenceContext tic, Type delegate_type)
{
AParametersCollection delegate_parameters = TypeManager.GetDelegateParameters (delegate_type);
- if (Parameters == Parameters.Undefined) {
+ if (Parameters == ParametersCompiled.Undefined) {
//
// We provide a set of inaccessible parameters
//
delegate_parameters.FixedParameters [i].ModFlags, null, loc);
}
- return Parameters.CreateFullyResolved (fixedpars, delegate_parameters.Types);
+ return ParametersCompiled.CreateFullyResolved (fixedpars, delegate_parameters.Types);
}
if (!VerifyExplicitParameters (delegate_type, delegate_parameters, ec.IsInProbingMode)) {
// anywhere', we depend on special conversion
// rules.
//
- type = TypeManager.anonymous_method_type;
+ type = InternalType.AnonymousMethod;
if ((Parameters != null) && !Parameters.Resolve (ec))
return null;
protected AnonymousMethodBody CompatibleMethod (EmitContext ec, TypeInferenceContext tic, Type return_type, Type delegate_type)
{
- Parameters p = ResolveParameters (ec, tic, delegate_type);
+ ParametersCompiled p = ResolveParameters (ec, tic, delegate_type);
if (p == null)
return null;
return anonymous;
}
- protected virtual AnonymousMethodBody CompatibleMethodFactory (Type return_type, Type delegate_type, Parameters p, ToplevelBlock b)
+ protected virtual AnonymousMethodBody CompatibleMethodFactory (Type return_type, Type delegate_type, ParametersCompiled p, ToplevelBlock b)
{
return new AnonymousMethodBody (p, b, return_type, delegate_type, loc);
}
public AnonymousMethodMethod (DeclSpace parent, AnonymousExpression am, AnonymousMethodStorey storey,
GenericMethod generic, TypeExpr return_type,
int mod, string real_name, MemberName name,
- Parameters parameters)
+ ParametersCompiled parameters)
: base (parent, generic, return_type, mod | Modifiers.COMPILER_GENERATED,
name, parameters, null)
{
IDisposable aec_dispose = null;
EmitContext.Flags flags = 0;
- if (ec.InferReturnType)
+ if (ec.InferReturnType) {
flags |= EmitContext.Flags.InferReturnType;
+ aec.ReturnTypeInference = new TypeInferenceContext ();
+ }
if (ec.IsInProbingMode)
flags |= EmitContext.Flags.ProbingMode;
bool unreachable;
bool res = aec.ResolveTopBlock (ec, Block, Block.Parameters, null, out unreachable);
- if (ec.InferReturnType)
- ReturnType = aec.ReturnType;
+ if (ec.InferReturnType) {
+ aec.ReturnTypeInference.FixAllTypes ();
+ ReturnType = aec.ReturnTypeInference.InferredTypeArguments [0];
+ }
if (aec_dispose != null) {
aec_dispose.Dispose ();
public class AnonymousMethodBody : AnonymousExpression
{
- protected readonly Parameters parameters;
+ protected readonly ParametersCompiled parameters;
AnonymousMethodStorey storey;
AnonymousMethodMethod method;
static int unique_id;
- public AnonymousMethodBody (Parameters parameters,
+ public AnonymousMethodBody (ParametersCompiled parameters,
ToplevelBlock block, Type return_type, Type delegate_type,
Location loc)
: base (block, return_type, loc)
}
MethodInfo delegate_method = method.MethodBuilder;
-#if GMCS_SOURCE
if (storey != null && storey.MemberName.IsGeneric) {
Type t = storey.Instance.Type;
t = storey.GetGenericStorey ().MutateType (t);
}
+#if GMCS_SOURCE
delegate_method = TypeBuilder.GetMethod (t, delegate_method);
- }
+#else
+ throw new NotSupportedException ();
#endif
+ }
+
ig.Emit (OpCodes.Ldftn, delegate_method);
ConstructorInfo constructor_method = Delegate.GetConstructor (ec.ContainerType, type);
//
public class AnonymousTypeClass : CompilerGeneratedClass
{
- sealed class AnonymousParameters : Parameters
+ sealed class AnonymousParameters : ParametersCompiled
{
public AnonymousParameters (params Parameter[] parameters)
: base (parameters)
public static AnonymousTypeClass Create (TypeContainer parent, ArrayList parameters, Location loc)
{
- if (RootContext.Version <= LanguageVersion.ISO_2)
- Report.FeatureIsNotAvailable (loc, "anonymous types");
+ if (RootContext.MetadataCompatibilityVersion < MetadataVersion.v2)
+ Report.FeatureIsNotSupported (loc, "anonymous types");
string name = ClassNamePrefix + types_counter++;
Method equals = new Method (this, null, TypeManager.system_boolean_expr,
Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN, new MemberName ("Equals", loc),
- Mono.CSharp.Parameters.CreateFullyResolved (new Parameter (null, "obj", 0, null, loc), TypeManager.object_type), null);
+ Mono.CSharp.ParametersCompiled.CreateFullyResolved (new Parameter (null, "obj", 0, null, loc), TypeManager.object_type), null);
Method tostring = new Method (this, null, TypeManager.system_string_expr,
Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN, new MemberName ("ToString", loc),
- Mono.CSharp.Parameters.EmptyReadOnlyParameters, null);
+ Mono.CSharp.ParametersCompiled.EmptyReadOnlyParameters, null);
ToplevelBlock equals_block = new ToplevelBlock (equals.Parameters, loc);
TypeExpr current_type;
new TypeArguments (new SimpleName (TypeParameters [i].Name, loc)), loc),
"Default", loc);
- ArrayList arguments_equal = new ArrayList (2);
+ Arguments arguments_equal = new Arguments (2);
arguments_equal.Add (new Argument (new MemberAccess (new This (f.Location), f.Name)));
arguments_equal.Add (new Argument (new MemberAccess (other_variable, f.Name)));
Expression field_equal = new Invocation (new MemberAccess (equality_comparer,
"Equals", loc), arguments_equal);
- ArrayList arguments_hashcode = new ArrayList (1);
+ Arguments arguments_hashcode = new Arguments (1);
arguments_hashcode.Add (new Argument (new MemberAccess (new This (f.Location), f.Name)));
Expression field_hashcode = new Invocation (new MemberAccess (equality_comparer,
"GetHashCode", loc), arguments_hashcode);
//
// Equals (object obj) override
- //
+ //
+ LocalVariableReference other_variable_assign = new LocalVariableReference (equals_block, "other", loc);
equals_block.AddStatement (new StatementExpression (
- new SimpleAssign (other_variable,
+ new SimpleAssign (other_variable_assign,
new As (equals_block.GetParameterReference ("obj", loc),
current_type, loc), loc)));
Method hashcode = new Method (this, null, TypeManager.system_int32_expr,
Modifiers.PUBLIC | Modifiers.OVERRIDE | Modifiers.DEBUGGER_HIDDEN,
new MemberName ("GetHashCode", loc),
- Mono.CSharp.Parameters.EmptyReadOnlyParameters, null);
+ Mono.CSharp.ParametersCompiled.EmptyReadOnlyParameters, null);
//
// Modified FNV with good avalanche behavior and uniform
hashcode_block.AddVariable (TypeManager.system_int32_expr, "hash", loc);
LocalVariableReference hash_variable = new LocalVariableReference (hashcode_block, "hash", loc);
+ LocalVariableReference hash_variable_assign = new LocalVariableReference (hashcode_block, "hash", loc);
hashcode_block.AddStatement (new StatementExpression (
- new SimpleAssign (hash_variable, rs_hashcode)));
+ new SimpleAssign (hash_variable_assign, rs_hashcode)));
hashcode_block.AddStatement (new StatementExpression (
new CompoundAssign (Binary.Operator.Addition, hash_variable,
projects / mono.git / blobdiff