X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fgmcs%2Fstatement.cs;h=69977e353094c7c7e8d904933c6246fbcb28a5fb;hb=60e8d68027b115d6b4c1df3e179bb0cd7b5ee171;hp=1405a5f4dd2084f9297abcf15585235df77510b3;hpb=2ad5619110abe6b88e5c4a9ea39a145719c1d7ff;p=mono.git diff --git a/mcs/gmcs/statement.cs b/mcs/gmcs/statement.cs index 1405a5f4dd2..69977e35309 100644 --- a/mcs/gmcs/statement.cs +++ b/mcs/gmcs/statement.cs @@ -139,11 +139,14 @@ namespace Mono.CSharp { public override bool Resolve (EmitContext ec) { + bool ok = true; + Report.Debug (1, "START IF BLOCK", loc); expr = Expression.ResolveBoolean (ec, expr, loc); if (expr == null){ - return false; + ok = false; + goto skip; } Assign ass = expr as Assign; @@ -172,22 +175,22 @@ namespace Mono.CSharp { if ((FalseStatement != null) && !FalseStatement.Resolve (ec)) - return false; - } + return false; + } return true; } - + skip: ec.StartFlowBranching (FlowBranching.BranchingType.Conditional, loc); - bool ok = TrueStatement.Resolve (ec); + ok &= TrueStatement.Resolve (ec); is_true_ret = ec.CurrentBranching.CurrentUsageVector.Reachability.IsUnreachable; ec.CurrentBranching.CreateSibling (); - if ((FalseStatement != null) && !FalseStatement.Resolve (ec)) - ok = false; + if (FalseStatement != null) + ok &= FalseStatement.Resolve (ec); ec.EndFlowBranching (); @@ -346,12 +349,14 @@ namespace Mono.CSharp { } ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc); + if (!infinite) + ec.CurrentBranching.CreateSibling (); if (!Statement.Resolve (ec)) ok = false; - ec.CurrentBranching.Infinite = infinite; - ec.EndFlowBranching (); + ec.CurrentBranching.Infinite = infinite; + ec.EndFlowBranching (); return ok; } @@ -530,7 +535,8 @@ namespace Mono.CSharp { public override bool Resolve (EmitContext ec) { - expr = expr.ResolveStatement (ec); + if (expr != null) + expr = expr.ResolveStatement (ec); return expr != null; } @@ -561,8 +567,15 @@ namespace Mono.CSharp { public override bool Resolve (EmitContext ec) { + AnonymousContainer am = ec.CurrentAnonymousMethod; + if ((am != null) && am.IsIterator && ec.InIterator) { + Report.Error (1622, loc, "Cannot return a value from iterators. Use the yield return " + + "statement to return a value, or yield break to end the iteration"); + return false; + } + if (ec.ReturnType == null){ - if (Expr != null){ + if (Expr != null){ if (ec.CurrentAnonymousMethod != null){ Report.Error (1662, loc, String.Format ( "Anonymous method could not be converted to delegate " + @@ -591,17 +604,12 @@ namespace Mono.CSharp { } } - if (ec.InIterator){ - Error (-206, "Return statement not allowed inside iterators"); - return false; - } - FlowBranching.UsageVector vector = ec.CurrentBranching.CurrentUsageVector; if (ec.CurrentBranching.InTryOrCatch (true)) { ec.CurrentBranching.AddFinallyVector (vector); in_exc = true; - } else if (ec.CurrentBranching.InFinally (true)) { + } else if (ec.InFinally) { Error (157, "Control can not leave the body of the finally block"); return false; } else @@ -632,7 +640,6 @@ namespace Mono.CSharp { public class Goto : Statement { string target; - Block block; LabeledStatement label; public override bool Resolve (EmitContext ec) @@ -651,9 +658,8 @@ namespace Mono.CSharp { return true; } - public Goto (Block parent_block, string label, Location l) + public Goto (string label, Location l) { - block = parent_block; loc = l; target = label; } @@ -851,10 +857,10 @@ namespace Mono.CSharp { } Type t = expr.Type; - + if ((t != TypeManager.exception_type) && - !t.IsSubclassOf (TypeManager.exception_type) && - !(expr is NullLiteral)) { + !TypeManager.IsSubclassOf (t, TypeManager.exception_type) && + !(expr is NullLiteral)) { Error (155, "The type caught or thrown must be derived " + "from System.Exception"); @@ -863,13 +869,13 @@ namespace Mono.CSharp { return true; } - if (ec.CurrentBranching.InFinally (true)) { - Error (724, "A throw statement with no argument is only allowed in a catch clause nested inside of the innermost catch clause"); + if (!ec.InCatch) { + Error (156, "A throw statement with no arguments is not allowed outside of a catch clause"); return false; } - if (!ec.CurrentBranching.InCatch ()) { - Error (156, "A throw statement with no argument is only allowed in a catch clause"); + if (ec.InFinally) { + Error (724, "A throw statement with no argument is only allowed in a catch clause nested inside of the innermost catch clause"); return false; } return true; @@ -901,13 +907,13 @@ namespace Mono.CSharp { if (!ec.CurrentBranching.InLoop () && !ec.CurrentBranching.InSwitch ()){ Error (139, "No enclosing loop or switch to continue to"); return false; - } else if (ec.CurrentBranching.InFinally (false)) { + } else if (ec.InFinally && ec.CurrentBranching.BreakCrossesTryCatchBoundary()) { Error (157, "Control can not leave the body of the finally block"); return false; } else if (ec.CurrentBranching.InTryOrCatch (false)) ec.CurrentBranching.AddFinallyVector ( ec.CurrentBranching.CurrentUsageVector); - else if (ec.CurrentBranching.InLoop ()) + else if (ec.CurrentBranching.InLoop () || ec.CurrentBranching.InSwitch ()) ec.CurrentBranching.AddBreakVector ( ec.CurrentBranching.CurrentUsageVector); @@ -946,7 +952,7 @@ namespace Mono.CSharp { if (!ec.CurrentBranching.InLoop () && !ec.CurrentBranching.InSwitch ()){ Error (139, "No enclosing loop to continue to"); return false; - } else if (ec.CurrentBranching.InFinally (false)) { + } else if (ec.InFinally) { Error (157, "Control can not leave the body of the finally block"); return false; } else if (ec.CurrentBranching.InTryOrCatch (false)) @@ -999,11 +1005,19 @@ namespace Mono.CSharp { Pinned = 4, IsThis = 8, Captured = 16, - AddressTaken = 32 + AddressTaken = 32, + CompilerGenerated = 64 } - Flags flags; + public enum ReadOnlyContext: byte { + Using, + Foreach, + Fixed + } + Flags flags; + ReadOnlyContext ro_context; + public LocalInfo (Expression type, string name, Block block, Location l) { Type = type; @@ -1097,6 +1111,16 @@ namespace Mono.CSharp { } } + public bool CompilerGenerated { + get { + return (flags & Flags.CompilerGenerated) != 0; + } + + set { + flags |= Flags.CompilerGenerated; + } + } + public override string ToString () { return String.Format ("LocalInfo ({0},{1},{2},{3})", @@ -1116,9 +1140,28 @@ namespace Mono.CSharp { get { return (flags & Flags.ReadOnly) != 0; } - set { - flags = value ? (flags | Flags.ReadOnly) : (unchecked (flags & ~Flags.ReadOnly)); + } + + public void SetReadOnlyContext (ReadOnlyContext context) + { + flags |= Flags.ReadOnly; + ro_context = context; + } + + public string GetReadOnlyContext () + { + if (!ReadOnly) + throw new InternalErrorException ("Variable is not readonly"); + + switch (ro_context) { + case ReadOnlyContext.Fixed: + return "fixed variable"; + case ReadOnlyContext.Foreach: + return "foreach iteration variable"; + case ReadOnlyContext.Using: + return "using variable"; } + throw new NotImplementedException (); } // @@ -1163,6 +1206,8 @@ namespace Mono.CSharp { public readonly Location StartLocation; public Location EndLocation = Location.Null; + public readonly ToplevelBlock Toplevel; + [Flags] public enum Flags { Implicit = 1, @@ -1227,7 +1272,7 @@ namespace Mono.CSharp { // statements. // ArrayList children; - + // // Labels. (label, block) pairs. // @@ -1243,9 +1288,9 @@ namespace Mono.CSharp { Hashtable constants; // - // The parameters for the block, this is only needed on the toplevel block really - // TODO: move `parameters' into ToplevelBlock - Parameters parameters; + // Temporary variables. + // + ArrayList temporary_variables; // // If this is a switch section, the enclosing switch block. @@ -1264,42 +1309,33 @@ namespace Mono.CSharp { : this (parent, flags, Location.Null, Location.Null) { } - public Block (Block parent, Flags flags, Parameters parameters) - : this (parent, flags, parameters, Location.Null, Location.Null) - { } - public Block (Block parent, Location start, Location end) : this (parent, (Flags) 0, start, end) { } - public Block (Block parent, Parameters parameters, Location start, Location end) - : this (parent, (Flags) 0, parameters, start, end) - { } - public Block (Block parent, Flags flags, Location start, Location end) - : this (parent, flags, Parameters.EmptyReadOnlyParameters, start, end) - { } - - public Block (Block parent, Flags flags, Parameters parameters, - Location start, Location end) { if (parent != null) parent.AddChild (this); this.Parent = parent; this.flags = flags; - this.parameters = parameters; this.StartLocation = start; this.EndLocation = end; this.loc = start; this_id = id++; statements = new ArrayList (); + if ((flags & Flags.IsToplevel) != 0) + Toplevel = (ToplevelBlock) this; + else + Toplevel = parent.Toplevel; + if (parent != null && Implicit) { - if (parent.child_variable_names == null) - parent.child_variable_names = new Hashtable(); + if (parent.known_variables == null) + parent.known_variables = new Hashtable (); // share with parent - child_variable_names = parent.child_variable_names; + known_variables = parent.known_variables; } } @@ -1446,30 +1482,54 @@ namespace Mono.CSharp { } } - Hashtable child_variable_names; + Hashtable known_variables; // - // Marks a variable with name @name as being used in a child block. + // Marks a variable with name @name as being used in this or a child block. // If a variable name has been used in a child block, it's illegal to // declare a variable with the same name in the current block. // - public void AddChildVariableName (string name) + void AddKnownVariable (string name, LocalInfo info) { - if (child_variable_names == null) - child_variable_names = new Hashtable (); + if (known_variables == null) + known_variables = new Hashtable (); - child_variable_names [name] = null; + known_variables [name] = info; } - // - // Checks whether a variable name has already been used in a child block. - // - public bool IsVariableNameUsedInChildBlock (string name) + LocalInfo GetKnownVariableInfo (string name) + { + if (known_variables == null) + return null; + return (LocalInfo) known_variables [name]; + } + + public bool CheckInvariantMeaningInBlock (string name, Expression e, Location loc) { - if (child_variable_names == null) + LocalInfo kvi = GetKnownVariableInfo (name); + if (kvi == null || kvi.Block == this) + return true; + + if (known_variables != kvi.Block.known_variables) { + Report.SymbolRelatedToPreviousError (kvi.Location, name); + Report.Error (135, loc, "'{0}' has a different meaning in a child block", name); return false; + } + + // + // this block and kvi.Block are the same textual block. + // However, different variables are extant. + // + // Check if the variable is in scope in both blocks. We use + // an indirect check that depends on AddVariable doing its + // part in maintaining the invariant-meaning-in-block property. + // + if (e is LocalVariableReference || (e is Constant && GetLocalInfo (name) != null)) + return true; - return child_variable_names.Contains (name); + Report.SymbolRelatedToPreviousError (kvi.Location, name); + Report.Error (136, loc, "'{0}' has a different meaning later in the block", name); + return false; } // @@ -1496,58 +1556,47 @@ namespace Mono.CSharp { return this_variable; } - public LocalInfo AddVariable (Expression type, string name, Parameters pars, Location l) + public LocalInfo AddVariable (Expression type, string name, Location l) { if (variables == null) variables = new Hashtable (); LocalInfo vi = GetLocalInfo (name); if (vi != null) { - if (vi.Block != this) - Report.Error (136, l, "A local variable named `" + name + "' " + - "cannot be declared in this scope since it would " + - "give a different meaning to `" + name + "', which " + - "is already used in a `parent or current' scope to " + - "denote something else"); + Report.SymbolRelatedToPreviousError (vi.Location, name); + if (known_variables == vi.Block.known_variables) + Report.Error (128, l, + "A local variable '{0}' is already declared in this scope", name); else - Report.Error (128, l, "A local variable `" + name + "' is already " + - "defined in this scope"); + Report.Error (136, l, + "'{0}' hides the declaration of local variable '{0}' in a parent scope", name); return null; } - if (IsVariableNameUsedInChildBlock (name)) { - Report.Error (136, l, "A local variable named `" + name + "' " + - "cannot be declared in this scope since it would " + - "give a different meaning to `" + name + "', which " + - "is already used in a `child' scope to denote something " + - "else"); + vi = GetKnownVariableInfo (name); + if (vi != null) { + Report.SymbolRelatedToPreviousError (vi.Location, name); + Report.Error (136, l, + "A child block already has a declaration of local variable '{0}':" + + " allowing this declaration would violate 'invariant meaning in a block'", + name); return null; } - if (pars != null) { - int idx; - Parameter p = pars.GetParameterByName (name, out idx); - if (p != null) { - Report.Error (136, l, "A local variable named `" + name + "' " + - "cannot be declared in this scope since it would " + - "give a different meaning to `" + name + "', which " + - "is already used in a `parent or current' scope to " + - "denote something else"); - return null; - } + int idx; + Parameter p = Toplevel.Parameters.GetParameterByName (name, out idx); + if (p != null) { + Report.SymbolRelatedToPreviousError (p.Location, name); + Report.Error (136, l, "'{0}' hides a method parameter", name); + return null; } vi = new LocalInfo (type, name, this, l); variables.Add (name, vi); - // Mark 'name' as "used by a child block" in every surrounding block - Block cur = this; - while (cur != null && cur.Implicit) - cur = cur.Parent; - if (cur != null) - for (Block par = cur.Parent; par != null; par = par.Parent) - par.AddChildVariableName (name); + for (Block b = this; b != null; b = b.Parent) + b.AddKnownVariable (name, vi); if ((flags & Flags.VariablesInitialized) != 0) throw new Exception (); @@ -1556,9 +1605,9 @@ namespace Mono.CSharp { return vi; } - public bool AddConstant (Expression type, string name, Expression value, Parameters pars, Location l) + public bool AddConstant (Expression type, string name, Expression value, Location l) { - if (AddVariable (type, name, pars, l) == null) + if (AddVariable (type, name, l) == null) return false; if (constants == null) @@ -1568,6 +1617,22 @@ namespace Mono.CSharp { return true; } + static int next_temp_id = 0; + + public LocalInfo AddTemporaryVariable (TypeExpr te, Location loc) + { + if (temporary_variables == null) + temporary_variables = new ArrayList (); + + int id = ++next_temp_id; + string name = "$s_" + id.ToString (); + + LocalInfo li = new LocalInfo (te, name, this, loc); + li.CompilerGenerated = true; + temporary_variables.Add (li); + return li; + } + public Hashtable Variables { get { return variables; @@ -1620,78 +1685,6 @@ namespace Mono.CSharp { return e != null; } - // - // Returns a `ParameterReference' for the given name, or null if there - // is no such parameter - // - public ParameterReference GetParameterReference (string name, Location loc) - { - Block b = this; - - do { - Parameters pars = b.parameters; - - if (pars != null){ - Parameter par; - int idx; - - par = pars.GetParameterByName (name, out idx); - if (par != null){ - ParameterReference pr; - - pr = new ParameterReference (pars, this, idx, name, loc); - return pr; - } - } - b = b.Parent; - } while (b != null); - return null; - } - - // - // Whether the parameter named `name' is local to this block, - // or false, if the parameter belongs to an encompassing block. - // - public bool IsLocalParameter (string name) - { - Block b = this; - int toplevel_count = 0; - - do { - if (this is ToplevelBlock) - toplevel_count++; - - Parameters pars = b.parameters; - if (pars != null){ - if (pars.GetParameterByName (name) != null) - return true; - return false; - } - if (toplevel_count > 0) - return false; - b = b.Parent; - } while (b != null); - return false; - } - - // - // Whether the `name' is a parameter reference - // - public bool IsParameterReference (string name) - { - Block b = this; - - do { - Parameters pars = b.parameters; - - if (pars != null) - if (pars.GetParameterByName (name) != null) - return true; - b = b.Parent; - } while (b != null); - return false; - } - /// /// A list of labels that were not used within this block /// @@ -1822,19 +1815,6 @@ namespace Mono.CSharp { continue; } -#if false - if (remap_locals) - vi.FieldBuilder = ec.MapVariable (name, vi.VariableType); - else if (vi.Pinned) - // - // This is needed to compile on both .NET 1.x and .NET 2.x - // the later introduced `DeclareLocal (Type t, bool pinned)' - // - vi.LocalBuilder = TypeManager.DeclareLocalPinned (ig, vi.VariableType); - else if (!vi.IsThis) - vi.LocalBuilder = ig.DeclareLocal (vi.VariableType); -#endif - if (constants == null) continue; @@ -1844,14 +1824,11 @@ namespace Mono.CSharp { ec.CurrentBlock = this; Expression e = cv.Resolve (ec); - if (e == null) - continue; Constant ce = e as Constant; if (ce == null){ Report.Error (133, vi.Location, - "The expression being assigned to `" + - name + "' must be constant (" + e + ")"); + "The expression being assigned to '{0}' must be constant", name); continue; } @@ -1886,7 +1863,6 @@ namespace Mono.CSharp { if (variables != null){ bool have_captured_vars = ec.HaveCapturedVariables (); - bool remap_locals = ec.RemapToProxy; foreach (DictionaryEntry de in variables){ LocalInfo vi = (LocalInfo) de.Value; @@ -1894,18 +1870,32 @@ namespace Mono.CSharp { if (have_captured_vars && ec.IsCaptured (vi)) continue; - if (remap_locals){ - vi.FieldBuilder = ec.MapVariable (vi.Name, vi.VariableType); - } else { - if (vi.Pinned) - // - // This is needed to compile on both .NET 1.x and .NET 2.x - // the later introduced `DeclareLocal (Type t, bool pinned)' - // - vi.LocalBuilder = TypeManager.DeclareLocalPinned (ig, vi.VariableType); - else if (!vi.IsThis) - vi.LocalBuilder = ig.DeclareLocal (vi.VariableType); - } + if (vi.Pinned) + // + // This is needed to compile on both .NET 1.x and .NET 2.x + // the later introduced `DeclareLocal (Type t, bool pinned)' + // + vi.LocalBuilder = TypeManager.DeclareLocalPinned (ig, vi.VariableType); + else if (!vi.IsThis) + vi.LocalBuilder = ig.DeclareLocal (vi.VariableType); + } + } + + if (temporary_variables != null) { + AnonymousContainer am = ec.CurrentAnonymousMethod; + TypeBuilder scope = null; + if ((am != null) && am.IsIterator) { + scope = am.Scope.ScopeTypeBuilder; + if (scope == null) + throw new InternalErrorException (); + } + foreach (LocalInfo vi in temporary_variables) { + if (scope != null) { + if (vi.FieldBuilder == null) + vi.FieldBuilder = scope.DefineField ( + vi.Name, vi.VariableType, FieldAttributes.Assembly); + } else + vi.LocalBuilder = ig.DeclareLocal (vi.VariableType); } } @@ -1938,6 +1928,7 @@ namespace Mono.CSharp { } bool unreachable_shown; + bool unreachable; public override bool Resolve (EmitContext ec) { @@ -1951,38 +1942,37 @@ namespace Mono.CSharp { Report.Debug (4, "RESOLVE BLOCK", StartLocation, ec.CurrentBranching); - bool unreachable = unreachable_shown; - + // + // This flag is used to notate nested statements as unreachable from the beginning of this block. + // For the purposes of this resolution, it doesn't matter that the whole block is unreachable + // from the beginning of the function. The outer Resolve() that detected the unreachability is + // responsible for handling the situation. + // int statement_count = statements.Count; for (int ix = 0; ix < statement_count; ix++){ Statement s = (Statement) statements [ix]; - - if (unreachable && !(s is LabeledStatement)) { - if (s == EmptyStatement.Value) - s.loc = EndLocation; - if (!s.ResolveUnreachable (ec, !unreachable_shown)) - ok = false; + if (unreachable) { + if (s is Block) + ((Block) s).unreachable = true; - if (s != EmptyStatement.Value) + if (!unreachable_shown && (RootContext.WarningLevel >= 2)) { + Report.Warning ( + 162, loc, "Unreachable code detected"); unreachable_shown = true; - else - s.loc = Location.Null; - - if (ok && !(s is Block)) { - statements [ix] = EmptyStatement.Value; - continue; } } - if (s.Resolve (ec) == false) { - ok = false; + if (!s.Resolve (ec)) { + ok = false; statements [ix] = EmptyStatement.Value; continue; } - num_statements = ix + 1; + if (unreachable && !(s is LabeledStatement) && !(s is Block)) + statements [ix] = EmptyStatement.Value; + num_statements = ix + 1; if (s is LabeledStatement) unreachable = false; else @@ -1992,7 +1982,6 @@ namespace Mono.CSharp { Report.Debug (4, "RESOLVE BLOCK DONE", StartLocation, ec.CurrentBranching, statement_count, num_statements); - FlowBranching.UsageVector vector = ec.DoEndFlowBranching (); ec.CurrentBlock = prev_block; @@ -2029,13 +2018,11 @@ namespace Mono.CSharp { public override bool ResolveUnreachable (EmitContext ec, bool warn) { unreachable_shown = true; + unreachable = true; if (warn && (RootContext.WarningLevel >= 2)) Report.Warning (162, loc, "Unreachable code detected"); - if (Implicit) - return Resolve (ec); - ec.StartFlowBranching (FlowBranching.BranchingType.Block, loc); bool ok = Resolve (ec); ec.KillFlowBranching (); @@ -2096,20 +2083,7 @@ namespace Mono.CSharp { ec.CurrentBlock = prev_block; } - public ToplevelBlock Toplevel { - get { - Block b = this; - while (b.Parent != null){ - if ((b.flags & Flags.IsToplevel) != 0) - break; - b = b.Parent; - } - - return (ToplevelBlock) b; - } - } - - // + // // Returns true if we ar ea child of `b'. // public bool IsChildOf (Block b) @@ -2123,6 +2097,11 @@ namespace Mono.CSharp { } while (current != null); return false; } + + public override string ToString () + { + return String.Format ("{0} ({1}:{2})", GetType (),ID, StartLocation); + } } // @@ -2138,13 +2117,17 @@ namespace Mono.CSharp { // Pointer to the host of this anonymous method, or null // if we are the topmost block // - public ToplevelBlock Container; + ToplevelBlock container; CaptureContext capture_context; + FlowBranching top_level_branching; Hashtable capture_contexts; + ArrayList children; - static int did = 0; - + // + // The parameters for the block. + // + public readonly Parameters Parameters; public void RegisterCaptureContext (CaptureContext cc) { @@ -2162,38 +2145,61 @@ namespace Mono.CSharp { cc.AdjustScopes (); } } - + public CaptureContext ToplevelBlockCaptureContext { get { return capture_context; } } - + + public ToplevelBlock Container { + get { + return container; + } + } + + protected void AddChild (ToplevelBlock block) + { + if (children == null) + children = new ArrayList (); + + children.Add (block); + } + // // Parent is only used by anonymous blocks to link back to their // parents // public ToplevelBlock (ToplevelBlock container, Parameters parameters, Location start) : - base (null, Flags.IsToplevel, parameters, start, Location.Null) + this (container, (Flags) 0, parameters, start) { - Container = container; } public ToplevelBlock (Parameters parameters, Location start) : - base (null, Flags.IsToplevel, parameters, start, Location.Null) + this (null, (Flags) 0, parameters, start) { } public ToplevelBlock (Flags flags, Parameters parameters, Location start) : - base (null, flags | Flags.IsToplevel, parameters, start, Location.Null) + this (null, flags, parameters, start) + { + } + + public ToplevelBlock (ToplevelBlock container, Flags flags, Parameters parameters, Location start) : + base (null, flags | Flags.IsToplevel, start, Location.Null) { + Parameters = parameters == null ? Parameters.EmptyReadOnlyParameters : parameters; + this.container = container; + + if (container != null) + container.AddChild (this); } - public ToplevelBlock (Location loc) : base (null, Flags.IsToplevel, loc, loc) + public ToplevelBlock (Location loc) : this (null, (Flags) 0, null, loc) { } - public void SetHaveAnonymousMethods (Location loc, AnonymousMethod host) + public void SetHaveAnonymousMethods (Location loc, AnonymousContainer host) { if (capture_context == null) capture_context = new CaptureContext (this, loc, host); @@ -2204,6 +2210,85 @@ namespace Mono.CSharp { return capture_context; } } + + public FlowBranching TopLevelBranching { + get { + return top_level_branching; + } + } + + // + // This is used if anonymous methods are used inside an iterator + // (see 2test-22.cs for an example). + // + // The AnonymousMethod is created while parsing - at a time when we don't + // know yet that we're inside an iterator, so it's `Container' is initially + // null. Later on, when resolving the iterator, we need to move the + // anonymous method into that iterator. + // + public void ReParent (ToplevelBlock new_parent, AnonymousContainer new_host) + { + foreach (ToplevelBlock block in children) { + if (block.CaptureContext == null) + continue; + + block.container = new_parent; + block.CaptureContext.ReParent (new_parent, new_host); + } + } + + // + // Returns a `ParameterReference' for the given name, or null if there + // is no such parameter + // + public ParameterReference GetParameterReference (string name, Location loc) + { + Parameter par; + int idx; + + for (ToplevelBlock t = this; t != null; t = t.Container) { + Parameters pars = t.Parameters; + par = pars.GetParameterByName (name, out idx); + if (par != null) + return new ParameterReference (pars, this, idx, name, loc); + } + return null; + } + + // + // Whether the parameter named `name' is local to this block, + // or false, if the parameter belongs to an encompassing block. + // + public bool IsLocalParameter (string name) + { + return Parameters.GetParameterByName (name) != null; + } + + // + // Whether the `name' is a parameter reference + // + public bool IsParameterReference (string name) + { + for (ToplevelBlock t = this; t != null; t = t.Container) { + if (t.IsLocalParameter (name)) + return true; + } + return false; + } + + public bool ResolveMeta (EmitContext ec, InternalParameters ip) + { + int errors = Report.Errors; + + if (top_level_branching != null) + return true; + + ResolveMeta (this, ec, ip); + + top_level_branching = ec.StartFlowBranching (this); + + return Report.Errors == errors; + } } public class SwitchLabel { @@ -2318,11 +2403,11 @@ namespace Mono.CSharp { // // Computed // - bool got_default; Label default_target; Expression new_expr; bool is_constant; SwitchSection constant_section; + SwitchSection default_section; // // The types allowed to be implicitly cast from @@ -2339,7 +2424,7 @@ namespace Mono.CSharp { public bool GotDefault { get { - return got_default; + return default_section != null; } } @@ -2444,8 +2529,6 @@ namespace Mono.CSharp { bool error = false; Elements = new Hashtable (); - got_default = false; - if (TypeManager.IsEnumType (SwitchType)){ compare_type = TypeManager.EnumToUnderlying (SwitchType); } else @@ -2459,11 +2542,11 @@ namespace Mono.CSharp { } if (sl.Label == null){ - if (got_default){ + if (default_section != null){ Report.Error (152, sl.loc, Error152, "default"); error = true; } - got_default = true; + default_section = ss; continue; } @@ -2869,12 +2952,11 @@ namespace Mono.CSharp { Label end_of_switch = ig.DefineLabel (); Label next_test = ig.DefineLabel (); Label null_target = ig.DefineLabel (); - bool default_found = false; bool first_test = true; bool pending_goto_end = false; + bool null_marked = false; bool null_found; - bool default_at_end = false; - + ig.Emit (OpCodes.Ldloc, val); if (Elements.Contains (NullLiteral.Null)){ @@ -2885,17 +2967,22 @@ namespace Mono.CSharp { ig.Emit (OpCodes.Ldloc, val); ig.Emit (OpCodes.Call, TypeManager.string_isinterneted_string); ig.Emit (OpCodes.Stloc, val); - + int section_count = Sections.Count; for (int section = 0; section < section_count; section++){ SwitchSection ss = (SwitchSection) Sections [section]; + + if (ss == default_section) + continue; + Label sec_begin = ig.DefineLabel (); + ig.Emit (OpCodes.Nop); + if (pending_goto_end) ig.Emit (OpCodes.Br, end_of_switch); int label_count = ss.Labels.Count; - bool mark_default = false; null_found = false; for (int label = 0; label < label_count; label++){ SwitchLabel sl = (SwitchLabel) ss.Labels [label]; @@ -2908,12 +2995,7 @@ namespace Mono.CSharp { // // If we are the default target // - if (sl.Label == null){ - if (label+1 == label_count) - default_at_end = true; - mark_default = true; - default_found = true; - } else { + if (sl.Label != null){ object lit = sl.Converted; if (lit is NullLiteral){ @@ -2937,24 +3019,24 @@ namespace Mono.CSharp { } } } - if (null_found) + if (null_found) { ig.MarkLabel (null_target); + null_marked = true; + } ig.MarkLabel (sec_begin); foreach (SwitchLabel sl in ss.Labels) ig.MarkLabel (sl.GetILLabelCode (ec)); - if (mark_default) - ig.MarkLabel (default_target); ss.Block.Emit (ec); pending_goto_end = !ss.Block.HasRet; first_test = false; } ig.MarkLabel (next_test); - if (default_found){ - if (!default_at_end) - ig.Emit (OpCodes.Br, default_target); - } else - ig.MarkLabel (default_target); + ig.MarkLabel (default_target); + if (!null_marked) + ig.MarkLabel (null_target); + if (default_section != null) + default_section.Block.Emit (ec); ig.MarkLabel (end_of_switch); } @@ -2970,24 +3052,6 @@ namespace Mono.CSharp { return null; } - bool ResolveConstantSwitch (EmitContext ec) - { - object key = ((Constant) new_expr).GetValue (); - SwitchLabel label = (SwitchLabel) Elements [key]; - - if (label == null) - return true; - - constant_section = FindSection (label); - if (constant_section == null) - return true; - - if (constant_section.Block.Resolve (ec) != true) - return false; - - return true; - } - public override bool Resolve (EmitContext ec) { Expr = Expr.Resolve (ec); @@ -3019,6 +3083,8 @@ namespace Mono.CSharp { SwitchLabel label = (SwitchLabel) Elements [key]; constant_section = FindSection (label); + if (constant_section == null) + constant_section = default_section; } bool first = true; @@ -3038,11 +3104,11 @@ namespace Mono.CSharp { return false; } else { if (!ss.Block.Resolve (ec)) - return false; + return false; } } - if (!got_default) + if (default_section == null) ec.CurrentBranching.CreateSibling ( null, FlowBranching.SiblingType.SwitchSection); @@ -3110,7 +3176,7 @@ namespace Mono.CSharp { { if (emit_finally) ec.ig.BeginFinallyBlock (); - else + else if (ec.InIterator) ec.CurrentIterator.MarkFinally (ec, parent_vectors); EmitFinally (ec); } @@ -3411,11 +3477,6 @@ namespace Mono.CSharp { CheckObsolete (expr_type); - if (ec.RemapToProxy){ - Report.Error (-210, loc, "Fixed statement not allowed in iterators"); - return false; - } - data = new Emitter [declarators.Count]; if (!expr_type.IsPointer){ @@ -3429,7 +3490,7 @@ namespace Mono.CSharp { Expression e = (Expression) p.Second; vi.VariableInfo.SetAssigned (ec); - vi.ReadOnly = true; + vi.SetReadOnlyContext (LocalInfo.ReadOnlyContext.Fixed); // // The rules for the possible declarators are pretty wise, @@ -3624,23 +3685,30 @@ namespace Mono.CSharp { public override bool Resolve (EmitContext ec) { - if (type_expr != null) { - TypeExpr te = type_expr.ResolveAsTypeTerminal (ec); - if (te == null) - return false; + bool was_catch = ec.InCatch; + ec.InCatch = true; + try { + if (type_expr != null) { + TypeExpr te = type_expr.ResolveAsTypeTerminal (ec); + if (te == null) + return false; - type = te.Type; + type = te.ResolveType (ec); - CheckObsolete (type); + CheckObsolete (type); - if (type != TypeManager.exception_type && !type.IsSubclassOf (TypeManager.exception_type)){ - Error (155, "The type caught or thrown must be derived from System.Exception"); - return false; - } - } else - type = null; + if (type != TypeManager.exception_type && !type.IsSubclassOf (TypeManager.exception_type)){ + Error (155, "The type caught or thrown must be derived from System.Exception"); + return false; + } + } else + type = null; - return Block.Resolve (ec); + return Block.Resolve (ec); + } + finally { + ec.InCatch = was_catch; + } } } @@ -3735,13 +3803,21 @@ namespace Mono.CSharp { Fini, FlowBranching.SiblingType.Finally); Report.Debug (1, "STARTED SIBLING FOR FINALLY", ec.CurrentBranching, vector); - + bool was_finally = ec.InFinally; + ec.InFinally = true; if (!Fini.Resolve (ec)) ok = false; + ec.InFinally = was_finally; + + if (!ec.InIterator) + need_exc_block = true; } - ResolveFinally (branching); - need_exc_block |= emit_finally; + if (ec.InIterator) { + ResolveFinally (branching); + need_exc_block |= emit_finally; + } else + emit_finally = Fini != null; FlowBranching.Reachability reachability = ec.EndFlowBranching (); @@ -3799,8 +3875,14 @@ namespace Mono.CSharp { public override void EmitFinally (EmitContext ec) { - if (Fini != null){ + if (Fini != null) Fini.Emit (ec); + } + + public bool HasCatch + { + get { + return General != null || Specific.Count > 0; } } } @@ -3894,11 +3976,11 @@ namespace Mono.CSharp { bool ResolveExpression (EmitContext ec) { if (!TypeManager.ImplementsInterface (expr_type, TypeManager.idisposable_type)){ - conv = Convert.ImplicitConversionRequired ( - ec, expr, TypeManager.idisposable_type, loc); - - if (conv == null) + if (Convert.ImplicitConversion (ec, expr, TypeManager.idisposable_type, loc) == null) { + Report.Error (1674, loc, "'{0}': type used in a using statement must be implicitly convertible to 'System.IDisposable'", + TypeManager.CSharpName (expr_type)); return false; + } } return true; @@ -4106,16 +4188,13 @@ namespace Mono.CSharp { /// /// Implementation of the foreach C# statement /// - public class Foreach : ExceptionStatement { + public class Foreach : Statement { Expression type; Expression variable; Expression expr; Statement statement; - ForeachHelperMethods hm; - Expression empty, conv; - Type array_type, element_type; - Type var_type; - VariableStorage enumerator; + ArrayForeach array; + CollectionForeach collection; public Foreach (Expression type, LocalVariableReference var, Expression expr, Statement stmt, Location l) @@ -4141,8 +4220,8 @@ namespace Mono.CSharp { TypeExpr texpr = type.ResolveAsTypeTerminal (ec); if (texpr == null) return false; - - var_type = texpr.Type; + + Type var_type = texpr.Type; // // We need an instance variable. Not sure this is the best @@ -4153,629 +4232,666 @@ namespace Mono.CSharp { // if (!(expr.eclass == ExprClass.Variable || expr.eclass == ExprClass.Value || expr.eclass == ExprClass.PropertyAccess || expr.eclass == ExprClass.IndexerAccess)){ - error1579 (expr.Type); + CollectionForeach.error1579 (expr.Type, loc); return false; } if (expr.Type.IsArray) { - array_type = expr.Type; - element_type = TypeManager.GetElementType (array_type); - - empty = new EmptyExpression (element_type); + array = new ArrayForeach (var_type, variable, expr, statement, loc); + return array.Resolve (ec); } else { - hm = ProbeCollectionType (ec, expr.Type); - if (hm == null){ - error1579 (expr.Type); - return false; - } + collection = new CollectionForeach ( + var_type, variable, expr, statement, loc); + return collection.Resolve (ec); + } + } - array_type = expr.Type; - element_type = hm.element_type; + protected override void DoEmit (EmitContext ec) + { + ILGenerator ig = ec.ig; + + Label old_begin = ec.LoopBegin, old_end = ec.LoopEnd; + ec.LoopBegin = ig.DefineLabel (); + ec.LoopEnd = ig.DefineLabel (); + + if (collection != null) + collection.Emit (ec); + else + array.Emit (ec); + + ec.LoopBegin = old_begin; + ec.LoopEnd = old_end; + } - empty = new EmptyExpression (hm.element_type); + protected class TemporaryVariable : Expression, IMemoryLocation + { + LocalInfo li; + + public TemporaryVariable (Type type, Location loc) + { + this.type = type; + this.loc = loc; + eclass = ExprClass.Value; } - bool ok = true; + public override Expression DoResolve (EmitContext ec) + { + if (li != null) + return this; - ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc); - ec.CurrentBranching.CreateSibling (); + TypeExpr te = new TypeExpression (type, loc); + li = ec.CurrentBlock.AddTemporaryVariable (te, loc); + if (!li.Resolve (ec)) + return null; - // - // - // FIXME: maybe we can apply the same trick we do in the - // array handling to avoid creating empty and conv in some cases. - // - // Although it is not as important in this case, as the type - // will not likely be object (what the enumerator will return). - // - conv = Convert.ExplicitConversion (ec, empty, var_type, loc); - if (conv == null) - ok = false; + AnonymousContainer am = ec.CurrentAnonymousMethod; + if ((am != null) && am.IsIterator) + ec.CaptureVariable (li); - variable = variable.ResolveLValue (ec, empty); - if (variable == null) - ok = false; + return this; + } - bool disposable = (hm != null) && hm.is_disposable; - FlowBranchingException branching = null; - if (disposable) - branching = ec.StartFlowBranching (this); + public override void Emit (EmitContext ec) + { + ILGenerator ig = ec.ig; - if (!statement.Resolve (ec)) - ok = false; + if (li.FieldBuilder != null) { + ig.Emit (OpCodes.Ldarg_0); + ig.Emit (OpCodes.Ldfld, li.FieldBuilder); + } else { + ig.Emit (OpCodes.Ldloc, li.LocalBuilder); + } + } - if (disposable) { - ResolveFinally (branching); - ec.EndFlowBranching (); - } else - emit_finally = true; + public void EmitLoadAddress (EmitContext ec) + { + ILGenerator ig = ec.ig; - ec.EndFlowBranching (); + if (li.FieldBuilder != null) { + ig.Emit (OpCodes.Ldarg_0); + ig.Emit (OpCodes.Ldflda, li.FieldBuilder); + } else { + ig.Emit (OpCodes.Ldloca, li.LocalBuilder); + } + } - return ok; - } - - // - // Retrieves a `public bool MoveNext ()' method from the Type `t' - // - static MethodInfo FetchMethodMoveNext (Type t) - { - MemberList move_next_list; - - move_next_list = TypeContainer.FindMembers ( - t, MemberTypes.Method, - BindingFlags.Public | BindingFlags.Instance, - Type.FilterName, "MoveNext"); - if (move_next_list.Count == 0) - return null; + public void Store (EmitContext ec, Expression right_side) + { + if (li.FieldBuilder != null) + ec.ig.Emit (OpCodes.Ldarg_0); - foreach (MemberInfo m in move_next_list){ - MethodInfo mi = (MethodInfo) m; - Type [] args; - - args = TypeManager.GetArgumentTypes (mi); - if (args != null && args.Length == 0){ - if (TypeManager.TypeToCoreType (mi.ReturnType) == TypeManager.bool_type) - return mi; + right_side.Emit (ec); + if (li.FieldBuilder != null) { + ec.ig.Emit (OpCodes.Stfld, li.FieldBuilder); + } else { + ec.ig.Emit (OpCodes.Stloc, li.LocalBuilder); } } - return null; - } - - // - // Retrieves a `public T get_Current ()' method from the Type `t' - // - static MethodInfo FetchMethodGetCurrent (Type t) - { - MemberList get_current_list; - get_current_list = TypeContainer.FindMembers ( - t, MemberTypes.Method, - BindingFlags.Public | BindingFlags.Instance, - Type.FilterName, "get_Current"); - if (get_current_list.Count == 0) - return null; + public void EmitThis (EmitContext ec) + { + if (li.FieldBuilder != null) { + ec.ig.Emit (OpCodes.Ldarg_0); + } + } - foreach (MemberInfo m in get_current_list){ - MethodInfo mi = (MethodInfo) m; - Type [] args; + public void EmitStore (ILGenerator ig) + { + if (li.FieldBuilder != null) + ig.Emit (OpCodes.Stfld, li.FieldBuilder); + else + ig.Emit (OpCodes.Stloc, li.LocalBuilder); + } - args = TypeManager.GetArgumentTypes (mi); - if (args != null && args.Length == 0) - return mi; + public void AddressOf (EmitContext ec, AddressOp mode) + { + EmitLoadAddress (ec); } - return null; } - // - // Retrieves a `public void Dispose ()' method from the Type `t' - // - static MethodInfo FetchMethodDispose (Type t) + protected class ArrayCounter : TemporaryVariable { - MemberList dispose_list; - - dispose_list = TypeContainer.FindMembers ( - t, MemberTypes.Method, - BindingFlags.Public | BindingFlags.Instance, - Type.FilterName, "Dispose"); - if (dispose_list.Count == 0) - return null; + public ArrayCounter (Location loc) + : base (TypeManager.int32_type, loc) + { } - foreach (MemberInfo m in dispose_list){ - MethodInfo mi = (MethodInfo) m; - Type [] args; - - args = TypeManager.GetArgumentTypes (mi); - if (args != null && args.Length == 0){ - if (mi.ReturnType == TypeManager.void_type) - return mi; - } + public void Initialize (EmitContext ec) + { + EmitThis (ec); + ec.ig.Emit (OpCodes.Ldc_I4_0); + EmitStore (ec.ig); } - return null; - } - // - // This struct records the helper methods used by the Foreach construct - // - class ForeachHelperMethods { - public EmitContext ec; - public MethodInfo get_enumerator; - public MethodInfo move_next; - public MethodInfo get_current; - public Type element_type; - public Type enumerator_type; - public bool is_disposable; - - public ForeachHelperMethods (EmitContext ec) + public void Increment (EmitContext ec) { - this.ec = ec; - this.element_type = TypeManager.object_type; - this.enumerator_type = TypeManager.ienumerator_type; - this.is_disposable = true; + EmitThis (ec); + Emit (ec); + ec.ig.Emit (OpCodes.Ldc_I4_1); + ec.ig.Emit (OpCodes.Add); + EmitStore (ec.ig); } } - - static bool GetEnumeratorFilter (MemberInfo m, object criteria) + + protected class ArrayForeach : Statement { - if (m == null) - return false; + Expression variable, expr, conv; + Statement statement; + Type array_type; + Type var_type; + TemporaryVariable[] lengths; + ArrayCounter[] counter; + int rank; - if (!(m is MethodInfo)) - return false; - - if (m.Name != "GetEnumerator") - return false; + TemporaryVariable copy; + Expression access; - MethodInfo mi = (MethodInfo) m; - Type [] args = TypeManager.GetArgumentTypes (mi); - if (args != null){ - if (args.Length != 0) - return false; + public ArrayForeach (Type var_type, Expression var, + Expression expr, Statement stmt, Location l) + { + this.var_type = var_type; + this.variable = var; + this.expr = expr; + statement = stmt; + loc = l; } - ForeachHelperMethods hm = (ForeachHelperMethods) criteria; - // Check whether GetEnumerator is public - if ((mi.Attributes & MethodAttributes.Public) != MethodAttributes.Public) - return false; + public override bool Resolve (EmitContext ec) + { + array_type = expr.Type; + rank = array_type.GetArrayRank (); - if ((mi.ReturnType == TypeManager.ienumerator_type) && (mi.DeclaringType == TypeManager.string_type)) - // - // Apply the same optimization as MS: skip the GetEnumerator - // returning an IEnumerator, and use the one returning a - // CharEnumerator instead. This allows us to avoid the - // try-finally block and the boxing. - // - return false; + copy = new TemporaryVariable (array_type, loc); + copy.Resolve (ec); - // - // Ok, we can access it, now make sure that we can do something - // with this `GetEnumerator' - // + counter = new ArrayCounter [rank]; + lengths = new TemporaryVariable [rank]; - Type return_type = mi.ReturnType; - if (mi.ReturnType == TypeManager.ienumerator_type || - TypeManager.ienumerator_type.IsAssignableFrom (return_type) || - (!RootContext.StdLib && TypeManager.ImplementsInterface (return_type, TypeManager.ienumerator_type))) { - - // - // If it is not an interface, lets try to find the methods ourselves. - // For example, if we have: - // public class Foo : IEnumerator { public bool MoveNext () {} public int Current { get {}}} - // We can avoid the iface call. This is a runtime perf boost. - // even bigger if we have a ValueType, because we avoid the cost - // of boxing. - // - // We have to make sure that both methods exist for us to take - // this path. If one of the methods does not exist, we will just - // use the interface. Sadly, this complex if statement is the only - // way I could do this without a goto - // - - if (return_type.IsInterface || - (hm.move_next = FetchMethodMoveNext (return_type)) == null || - (hm.get_current = FetchMethodGetCurrent (return_type)) == null) { - - hm.move_next = TypeManager.bool_movenext_void; - hm.get_current = TypeManager.object_getcurrent_void; - return true; - } + ArrayList list = new ArrayList (); + for (int i = 0; i < rank; i++) { + counter [i] = new ArrayCounter (loc); + counter [i].Resolve (ec); - } else { + lengths [i] = new TemporaryVariable (TypeManager.int32_type, loc); + lengths [i].Resolve (ec); - // - // Ok, so they dont return an IEnumerable, we will have to - // find if they support the GetEnumerator pattern. - // - - hm.move_next = FetchMethodMoveNext (return_type); - if (hm.move_next == null) + list.Add (counter [i]); + } + + access = new ElementAccess (copy, list, loc).Resolve (ec); + if (access == null) return false; - - hm.get_current = FetchMethodGetCurrent (return_type); - if (hm.get_current == null) + + conv = Convert.ExplicitConversion (ec, access, var_type, loc); + if (conv == null) return false; + + bool ok = true; + + ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc); + ec.CurrentBranching.CreateSibling (); + + variable = variable.ResolveLValue (ec, conv); + if (variable == null) + ok = false; + + if (!statement.Resolve (ec)) + ok = false; + + ec.EndFlowBranching (); + + return ok; } - - hm.element_type = hm.get_current.ReturnType; - hm.enumerator_type = return_type; - hm.is_disposable = !hm.enumerator_type.IsSealed || - TypeManager.ImplementsInterface ( - hm.enumerator_type, TypeManager.idisposable_type); - return true; - } - - /// - /// This filter is used to find the GetEnumerator method - /// on which IEnumerator operates - /// - static MemberFilter FilterEnumerator; - - static Foreach () - { - FilterEnumerator = new MemberFilter (GetEnumeratorFilter); - } + protected override void DoEmit (EmitContext ec) + { + ILGenerator ig = ec.ig; - void error1579 (Type t) - { - Report.Error (1579, loc, - "foreach statement cannot operate on variables of type `" + - t.FullName + "' because that class does not provide a " + - " GetEnumerator method or it is inaccessible"); - } + copy.Store (ec, expr); - static bool TryType (Type t, ForeachHelperMethods hm) - { - MemberList mi; - - mi = TypeContainer.FindMembers (t, MemberTypes.Method, - BindingFlags.Public | BindingFlags.NonPublic | - BindingFlags.Instance | BindingFlags.DeclaredOnly, - FilterEnumerator, hm); + Label[] test = new Label [rank]; + Label[] loop = new Label [rank]; - if (mi.Count == 0) - return false; + for (int i = 0; i < rank; i++) { + test [i] = ig.DefineLabel (); + loop [i] = ig.DefineLabel (); + + lengths [i].EmitThis (ec); + ((ArrayAccess) access).EmitGetLength (ec, i); + lengths [i].EmitStore (ig); + } + + for (int i = 0; i < rank; i++) { + counter [i].Initialize (ec); + + ig.Emit (OpCodes.Br, test [i]); + ig.MarkLabel (loop [i]); + } - hm.get_enumerator = (MethodInfo) mi [0]; - return true; + ((IAssignMethod) variable).EmitAssign (ec, conv, false, false); + + statement.Emit (ec); + + ig.MarkLabel (ec.LoopBegin); + + for (int i = rank - 1; i >= 0; i--){ + counter [i].Increment (ec); + + ig.MarkLabel (test [i]); + counter [i].Emit (ec); + lengths [i].Emit (ec); + ig.Emit (OpCodes.Blt, loop [i]); + } + + ig.MarkLabel (ec.LoopEnd); + } } - - // - // Looks for a usable GetEnumerator in the Type, and if found returns - // the three methods that participate: GetEnumerator, MoveNext and get_Current - // - ForeachHelperMethods ProbeCollectionType (EmitContext ec, Type t) + + protected class CollectionForeach : ExceptionStatement { - ForeachHelperMethods hm = new ForeachHelperMethods (ec); + Expression variable, expr; + Statement statement; - for (Type tt = t; tt != null && tt != TypeManager.object_type;){ - if (TryType (tt, hm)) - return hm; - tt = tt.BaseType; - } + TemporaryVariable enumerator; + Expression init; + Statement loop; - // - // Now try to find the method in the interfaces - // - while (t != null){ - Type [] ifaces = t.GetInterfaces (); + MethodGroupExpr get_enumerator; + PropertyExpr get_current; + MethodInfo move_next; + Type var_type, enumerator_type; + bool is_disposable; + + public CollectionForeach (Type var_type, Expression var, + Expression expr, Statement stmt, Location l) + { + this.var_type = var_type; + this.variable = var; + this.expr = expr; + statement = stmt; + loc = l; + } - foreach (Type i in ifaces){ - if (TryType (i, hm)) - return hm; + bool GetEnumeratorFilter (EmitContext ec, MethodInfo mi) + { + Type [] args = TypeManager.GetArgumentTypes (mi); + if (args != null){ + if (args.Length != 0) + return false; } - + + if (TypeManager.IsOverride (mi)) + return false; + + // Check whether GetEnumerator is public + if ((mi.Attributes & MethodAttributes.Public) != MethodAttributes.Public) + return false; + + if ((mi.ReturnType == TypeManager.ienumerator_type) && (mi.DeclaringType == TypeManager.string_type)) + // + // Apply the same optimization as MS: skip the GetEnumerator + // returning an IEnumerator, and use the one returning a + // CharEnumerator instead. This allows us to avoid the + // try-finally block and the boxing. + // + return false; + // - // Since TypeBuilder.GetInterfaces only returns the interface - // types for this type, we have to keep looping, but once - // we hit a non-TypeBuilder (ie, a Type), then we know we are - // done, because it returns all the types + // Ok, we can access it, now make sure that we can do something + // with this `GetEnumerator' // - if ((t is TypeBuilder)) - t = t.BaseType; - else - break; - } - - return null; - } - // - // FIXME: possible optimization. - // We might be able to avoid creating `empty' if the type is the sam - // - bool EmitCollectionForeach (EmitContext ec) - { - ILGenerator ig = ec.ig; + Type return_type = mi.ReturnType; + if (mi.ReturnType == TypeManager.ienumerator_type || + TypeManager.ienumerator_type.IsAssignableFrom (return_type) || + (!RootContext.StdLib && TypeManager.ImplementsInterface (return_type, TypeManager.ienumerator_type))) { + // + // If it is not an interface, lets try to find the methods ourselves. + // For example, if we have: + // public class Foo : IEnumerator { public bool MoveNext () {} public int Current { get {}}} + // We can avoid the iface call. This is a runtime perf boost. + // even bigger if we have a ValueType, because we avoid the cost + // of boxing. + // + // We have to make sure that both methods exist for us to take + // this path. If one of the methods does not exist, we will just + // use the interface. Sadly, this complex if statement is the only + // way I could do this without a goto + // - enumerator = new VariableStorage (ec, hm.enumerator_type); - enumerator.EmitThis (ig); - // - // Instantiate the enumerator - // - if (expr.Type.IsValueType){ - IMemoryLocation ml = expr as IMemoryLocation; - // Load the address of the value type. - if (ml == null) { - // This happens if, for example, you have a property - // returning a struct which is IEnumerable - LocalBuilder t = ec.GetTemporaryLocal (expr.Type); - expr.Emit(ec); - ig.Emit (OpCodes.Stloc, t); - ig.Emit (OpCodes.Ldloca, t); - ec.FreeTemporaryLocal (t, expr.Type); - } else { - ml.AddressOf (ec, AddressOp.Load); + if (return_type.IsInterface || + !FetchMoveNext (ec, return_type) || + !FetchGetCurrent (ec, return_type)) { + move_next = TypeManager.bool_movenext_void; + get_current = new PropertyExpr ( + ec, TypeManager.ienumerator_getcurrent, loc); + return true; } - - // Emit the call. - if (hm.get_enumerator.DeclaringType.IsValueType) { - // the method is declared on the value type - ig.Emit (OpCodes.Call, hm.get_enumerator); } else { - // it is an interface method, so we must box - ig.Emit (OpCodes.Box, expr.Type); - ig.Emit (OpCodes.Callvirt, hm.get_enumerator); + // + // Ok, so they dont return an IEnumerable, we will have to + // find if they support the GetEnumerator pattern. + // + + if (!FetchMoveNext (ec, return_type)) + return false; + + if (!FetchGetCurrent (ec, return_type)) + return false; } - } else { - expr.Emit (ec); - ig.Emit (OpCodes.Callvirt, hm.get_enumerator); + + enumerator_type = return_type; + is_disposable = !enumerator_type.IsSealed || + TypeManager.ImplementsInterface ( + enumerator_type, TypeManager.idisposable_type); + + return true; } - enumerator.EmitStore (ig); // - // Protect the code in a try/finalize block, so that - // if the beast implement IDisposable, we get rid of it + // Retrieves a `public bool MoveNext ()' method from the Type `t' // - if (hm.is_disposable && emit_finally) - ig.BeginExceptionBlock (); - - Label end_try = ig.DefineLabel (); - - ig.MarkLabel (ec.LoopBegin); - - enumerator.EmitCall (ig, hm.move_next); - - ig.Emit (OpCodes.Brfalse, end_try); + bool FetchMoveNext (EmitContext ec, Type t) + { + MemberList move_next_list; - if (ec.InIterator) - ig.Emit (OpCodes.Ldarg_0); - - enumerator.EmitCall (ig, hm.get_current); + move_next_list = TypeContainer.FindMembers ( + t, MemberTypes.Method, + BindingFlags.Public | BindingFlags.Instance, + Type.FilterName, "MoveNext"); + if (move_next_list.Count == 0) + return false; - if (ec.InIterator){ - conv.Emit (ec); - ig.Emit (OpCodes.Stfld, ((LocalVariableReference) variable).local_info.FieldBuilder); - } else - ((IAssignMethod)variable).EmitAssign (ec, conv, false, false); + foreach (MemberInfo m in move_next_list){ + MethodInfo mi = (MethodInfo) m; + Type [] args; - statement.Emit (ec); - ig.Emit (OpCodes.Br, ec.LoopBegin); - ig.MarkLabel (end_try); - - // The runtime provides this for us. - // ig.Emit (OpCodes.Leave, end); + args = TypeManager.GetArgumentTypes (mi); + if ((args != null) && (args.Length == 0) && + TypeManager.TypeToCoreType (mi.ReturnType) == TypeManager.bool_type) { + move_next = mi; + return true; + } + } + return false; + } + // - // Now the finally block + // Retrieves a `public T get_Current ()' method from the Type `t' // - if (hm.is_disposable) { - DoEmitFinally (ec); - if (emit_finally) - ig.EndExceptionBlock (); + bool FetchGetCurrent (EmitContext ec, Type t) + { + PropertyExpr pe = Expression.MemberLookup ( + ec, t, "Current", MemberTypes.Property, + Expression.AllBindingFlags, loc) as PropertyExpr; + if (pe == null) + return false; + + get_current = pe; + return true; } - ig.MarkLabel (ec.LoopEnd); - return false; - } + // + // Retrieves a `public void Dispose ()' method from the Type `t' + // + static MethodInfo FetchMethodDispose (Type t) + { + MemberList dispose_list; - public override void EmitFinally (EmitContext ec) - { - ILGenerator ig = ec.ig; + dispose_list = TypeContainer.FindMembers ( + t, MemberTypes.Method, + BindingFlags.Public | BindingFlags.Instance, + Type.FilterName, "Dispose"); + if (dispose_list.Count == 0) + return null; - if (hm.enumerator_type.IsValueType) { - enumerator.EmitThis (ig); + foreach (MemberInfo m in dispose_list){ + MethodInfo mi = (MethodInfo) m; + Type [] args; - MethodInfo mi = FetchMethodDispose (hm.enumerator_type); - if (mi != null) { - enumerator.EmitLoadAddress (ig); - ig.Emit (OpCodes.Call, mi); - } else { - enumerator.EmitLoad (ig); - ig.Emit (OpCodes.Box, hm.enumerator_type); - ig.Emit (OpCodes.Callvirt, TypeManager.void_dispose_void); + args = TypeManager.GetArgumentTypes (mi); + if (args != null && args.Length == 0){ + if (mi.ReturnType == TypeManager.void_type) + return mi; + } } - } else { - Label call_dispose = ig.DefineLabel (); - - enumerator.EmitThis (ig); - enumerator.EmitLoad (ig); - ig.Emit (OpCodes.Isinst, TypeManager.idisposable_type); - ig.Emit (OpCodes.Dup); - ig.Emit (OpCodes.Brtrue_S, call_dispose); - ig.Emit (OpCodes.Pop); + return null; + } - Label end_finally = ig.DefineLabel (); - ig.Emit (OpCodes.Br, end_finally); + static public void error1579 (Type t, Location loc) + { + Report.Error (1579, loc, "foreach statement cannot operate on " + + "variables of type `{0}' because that class does " + + "not provide a GetEnumerator method or it is " + + "inaccessible", t.FullName); + } - ig.MarkLabel (call_dispose); - ig.Emit (OpCodes.Callvirt, TypeManager.void_dispose_void); - ig.MarkLabel (end_finally); + bool TryType (EmitContext ec, Type t) + { + MethodGroupExpr mg = Expression.MemberLookup ( + ec, t, "GetEnumerator", MemberTypes.Method, + Expression.AllBindingFlags, loc) as MethodGroupExpr; + if (mg == null) + return false; - if (emit_finally) - ig.Emit (OpCodes.Endfinally); - } - } + foreach (MethodBase mb in mg.Methods) { + if (!GetEnumeratorFilter (ec, (MethodInfo) mb)) + continue; - // - // FIXME: possible optimization. - // We might be able to avoid creating `empty' if the type is the sam - // - bool EmitArrayForeach (EmitContext ec) - { - int rank = array_type.GetArrayRank (); - ILGenerator ig = ec.ig; + MethodInfo[] mi = new MethodInfo[] { (MethodInfo) mb }; + get_enumerator = new MethodGroupExpr (mi, loc); - VariableStorage copy = new VariableStorage (ec, array_type); - - // - // Make our copy of the array - // - copy.EmitThis (ig); - expr.Emit (ec); - copy.EmitStore (ig); - - if (rank == 1){ - VariableStorage counter = new VariableStorage (ec,TypeManager.int32_type); + if (t != expr.Type) { + expr = Convert.ExplicitConversion ( + ec, expr, t, loc); + if (expr == null) + throw new InternalErrorException (); + } - Label loop, test; + get_enumerator.InstanceExpression = expr; + get_enumerator.IsBase = t != expr.Type; - counter.EmitThis (ig); - ig.Emit (OpCodes.Ldc_I4_0); - counter.EmitStore (ig); - test = ig.DefineLabel (); - ig.Emit (OpCodes.Br, test); + return true; + } - loop = ig.DefineLabel (); - ig.MarkLabel (loop); + return false; + } - if (ec.InIterator) - ig.Emit (OpCodes.Ldarg_0); - - copy.EmitThis (ig); - copy.EmitLoad (ig); - counter.EmitThis (ig); - counter.EmitLoad (ig); + bool ProbeCollectionType (EmitContext ec, Type t) + { + for (Type tt = t; tt != null && tt != TypeManager.object_type;){ + if (TryType (ec, tt)) + return true; + tt = tt.BaseType; + } // - // Load the value, we load the value using the underlying type, - // then we use the variable.EmitAssign to load using the proper cast. + // Now try to find the method in the interfaces // - ArrayAccess.EmitLoadOpcode (ig, element_type); - if (ec.InIterator){ - conv.Emit (ec); - ig.Emit (OpCodes.Stfld, ((LocalVariableReference) variable).local_info.FieldBuilder); - } else - ((IAssignMethod)variable).EmitAssign (ec, conv, false, false); + while (t != null){ + Type [] ifaces = t.GetInterfaces (); - statement.Emit (ec); - - ig.MarkLabel (ec.LoopBegin); - counter.EmitThis (ig); - counter.EmitThis (ig); - counter.EmitLoad (ig); - ig.Emit (OpCodes.Ldc_I4_1); - ig.Emit (OpCodes.Add); - counter.EmitStore (ig); - - ig.MarkLabel (test); - counter.EmitThis (ig); - counter.EmitLoad (ig); - copy.EmitThis (ig); - copy.EmitLoad (ig); - ig.Emit (OpCodes.Ldlen); - ig.Emit (OpCodes.Conv_I4); - ig.Emit (OpCodes.Blt, loop); - } else { - VariableStorage [] dim_len = new VariableStorage [rank]; - VariableStorage [] dim_count = new VariableStorage [rank]; - Label [] loop = new Label [rank]; - Label [] test = new Label [rank]; - int dim; + foreach (Type i in ifaces){ + if (TryType (ec, i)) + return true; + } - for (dim = 0; dim < rank; dim++){ - dim_len [dim] = new VariableStorage (ec, TypeManager.int32_type); - dim_count [dim] = new VariableStorage (ec, TypeManager.int32_type); - test [dim] = ig.DefineLabel (); - loop [dim] = ig.DefineLabel (); - } - - for (dim = 0; dim < rank; dim++){ - dim_len [dim].EmitThis (ig); - copy.EmitThis (ig); - copy.EmitLoad (ig); - IntLiteral.EmitInt (ig, dim); - ig.Emit (OpCodes.Callvirt, TypeManager.int_getlength_int); - dim_len [dim].EmitStore (ig); - + // + // Since TypeBuilder.GetInterfaces only returns the interface + // types for this type, we have to keep looping, but once + // we hit a non-TypeBuilder (ie, a Type), then we know we are + // done, because it returns all the types + // + if ((t is TypeBuilder)) + t = t.BaseType; + else + break; } - for (dim = 0; dim < rank; dim++){ - dim_count [dim].EmitThis (ig); - ig.Emit (OpCodes.Ldc_I4_0); - dim_count [dim].EmitStore (ig); - ig.Emit (OpCodes.Br, test [dim]); - ig.MarkLabel (loop [dim]); + return false; + } + + public override bool Resolve (EmitContext ec) + { + enumerator_type = TypeManager.ienumerator_type; + is_disposable = true; + + if (!ProbeCollectionType (ec, expr.Type)) { + error1579 (expr.Type, loc); + return false; } - if (ec.InIterator) - ig.Emit (OpCodes.Ldarg_0); - - copy.EmitThis (ig); - copy.EmitLoad (ig); - for (dim = 0; dim < rank; dim++){ - dim_count [dim].EmitThis (ig); - dim_count [dim].EmitLoad (ig); + enumerator = new TemporaryVariable (enumerator_type, loc); + enumerator.Resolve (ec); + + init = new Invocation (get_enumerator, new ArrayList (), loc); + init = init.Resolve (ec); + if (init == null) + return false; + + Expression move_next_expr; + { + MemberInfo[] mi = new MemberInfo[] { move_next }; + MethodGroupExpr mg = new MethodGroupExpr (mi, loc); + mg.InstanceExpression = enumerator; + + move_next_expr = new Invocation (mg, new ArrayList (), loc); } + get_current.InstanceExpression = enumerator; + + Statement block = new CollectionForeachStatement ( + var_type, variable, get_current, statement, loc); + + loop = new While (move_next_expr, block, loc); + + bool ok = true; + + ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc); + ec.CurrentBranching.CreateSibling (); + + FlowBranchingException branching = null; + if (is_disposable) + branching = ec.StartFlowBranching (this); + + if (!loop.Resolve (ec)) + ok = false; + + if (is_disposable) { + ResolveFinally (branching); + ec.EndFlowBranching (); + } else + emit_finally = true; + + ec.EndFlowBranching (); + + return ok; + } + + protected override void DoEmit (EmitContext ec) + { + ILGenerator ig = ec.ig; + + enumerator.Store (ec, init); + // - // FIXME: Maybe we can cache the computation of `get'? + // Protect the code in a try/finalize block, so that + // if the beast implement IDisposable, we get rid of it // - Type [] args = new Type [rank]; - MethodInfo get; - - for (int i = 0; i < rank; i++) - args [i] = TypeManager.int32_type; - - ModuleBuilder mb = CodeGen.Module.Builder; - get = mb.GetArrayMethod ( - array_type, "Get", - CallingConventions.HasThis| CallingConventions.Standard, - var_type, args); - ig.Emit (OpCodes.Call, get); - if (ec.InIterator){ - conv.Emit (ec); - ig.Emit (OpCodes.Stfld, ((LocalVariableReference) variable).local_info.FieldBuilder); - } else - ((IAssignMethod)variable).EmitAssign (ec, conv, false, false); - statement.Emit (ec); - ig.MarkLabel (ec.LoopBegin); - for (dim = rank - 1; dim >= 0; dim--){ - dim_count [dim].EmitThis (ig); - dim_count [dim].EmitThis (ig); - dim_count [dim].EmitLoad (ig); - ig.Emit (OpCodes.Ldc_I4_1); - ig.Emit (OpCodes.Add); - dim_count [dim].EmitStore (ig); - - ig.MarkLabel (test [dim]); - dim_count [dim].EmitThis (ig); - dim_count [dim].EmitLoad (ig); - dim_len [dim].EmitThis (ig); - dim_len [dim].EmitLoad (ig); - ig.Emit (OpCodes.Blt, loop [dim]); + if (is_disposable && emit_finally) + ig.BeginExceptionBlock (); + + loop.Emit (ec); + + // + // Now the finally block + // + if (is_disposable) { + DoEmitFinally (ec); + if (emit_finally) + ig.EndExceptionBlock (); + } + } + + + public override void EmitFinally (EmitContext ec) + { + ILGenerator ig = ec.ig; + + if (enumerator_type.IsValueType) { + enumerator.Emit (ec); + + MethodInfo mi = FetchMethodDispose (enumerator_type); + if (mi != null) { + enumerator.EmitLoadAddress (ec); + ig.Emit (OpCodes.Call, mi); + } else { + enumerator.Emit (ec); + ig.Emit (OpCodes.Box, enumerator_type); + ig.Emit (OpCodes.Callvirt, TypeManager.void_dispose_void); + } + } else { + Label call_dispose = ig.DefineLabel (); + + enumerator.Emit (ec); + ig.Emit (OpCodes.Isinst, TypeManager.idisposable_type); + ig.Emit (OpCodes.Dup); + ig.Emit (OpCodes.Brtrue_S, call_dispose); + ig.Emit (OpCodes.Pop); + + Label end_finally = ig.DefineLabel (); + ig.Emit (OpCodes.Br, end_finally); + + ig.MarkLabel (call_dispose); + ig.Emit (OpCodes.Callvirt, TypeManager.void_dispose_void); + ig.MarkLabel (end_finally); } } - ig.MarkLabel (ec.LoopEnd); - - return false; } - - protected override void DoEmit (EmitContext ec) + + protected class CollectionForeachStatement : Statement { - ILGenerator ig = ec.ig; - - Label old_begin = ec.LoopBegin, old_end = ec.LoopEnd; - ec.LoopBegin = ig.DefineLabel (); - ec.LoopEnd = ig.DefineLabel (); - - if (hm != null) - EmitCollectionForeach (ec); - else - EmitArrayForeach (ec); - - ec.LoopBegin = old_begin; - ec.LoopEnd = old_end; + Type type; + Expression variable, current, conv; + Statement statement; + Assign assign; + + public CollectionForeachStatement (Type type, Expression variable, + Expression current, Statement statement, + Location loc) + { + this.type = type; + this.variable = variable; + this.current = current; + this.statement = statement; + this.loc = loc; + } + + public override bool Resolve (EmitContext ec) + { + current = current.Resolve (ec); + if (current == null) + return false; + + conv = Convert.ExplicitConversion (ec, current, type, loc); + if (conv == null) + return false; + + assign = new Assign (variable, conv, loc); + if (assign.Resolve (ec) == null) + return false; + + if (!statement.Resolve (ec)) + return false; + + return true; + } + + protected override void DoEmit (EmitContext ec) + { + assign.EmitStatement (ec); + statement.Emit (ec); + } } } }