// be called first, otherwise _this_ will be initialized with
// uninitialized value.
//
- public sealed class ThisInitializer : Statement
+ sealed class ThisInitializer : Statement
{
- readonly AnonymousMethodStorey storey;
+ readonly HoistedThis hoisted_this;
- public ThisInitializer (AnonymousMethodStorey storey)
+ public ThisInitializer (HoistedThis hoisted_this)
{
- this.storey = storey;
+ this.hoisted_this = hoisted_this;
}
protected override void DoEmit (EmitContext ec)
{
- if (storey.hoisted_this != null) {
- storey.hoisted_this.EmitHoistingAssignment (ec);
- }
+ hoisted_this.EmitHoistingAssignment (ec);
}
protected override void CloneTo (CloneContext clonectx, Statement target)
TypeArguments targs = new TypeArguments ();
if (tparams.Length < CountTypeParameters) {
- TypeParameter[] parent_tparams = ec.DeclContainer.Parent.CurrentTypeParameters;
+ TypeParameter[] parent_tparams = ec.DeclContainer.Parent.PartialContainer.TypeParameters;
for (int i = 0; i < parent_tparams.Length; ++i)
targs.Add (new TypeParameterExpr (parent_tparams[i], Location));
}
//
if (OriginalSourceBlock.Explicit.HasCapturedThis && !(Parent is AnonymousMethodStorey)) {
AddCapturedThisField (ec);
- hoisted_this.EmitHoistingAssignment (ec);
+ OriginalSourceBlock.AddScopeStatement (new ThisInitializer (hoisted_this));
}
//
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);
{
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);
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
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);
if (am == null)
return null;
+ // Stop referencing gmcs NullLiteral type
if (am.ReturnType == TypeManager.null_type)
am.ReturnType = null;
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)) {
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)
{
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;
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
projects / mono.git / blobdiff