edit: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/AstGenerator.cs;C601093 File: AstGenerator.cs =================================================================== --- $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/AstGenerator.cs;C601093 (server) 10/17/2008 12:59 PM +++ Shelved Change: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/AstGenerator.cs;Blocks @@ -610,10 +610,22 @@ } internal MSA.Expression/*!*/ TransformStatements(List/*!*/ statements, ResultOperation resultOperation) { + return TransformStatements(null, statements, null, resultOperation); + } + + internal MSA.Expression/*!*/ TransformStatements(MSA.Expression prologue, List/*!*/ statements, ResultOperation resultOperation) { + return TransformStatements(prologue, statements, null, resultOperation); + } + + internal MSA.Expression/*!*/ TransformStatements(MSA.Expression prologue, List/*!*/ statements, MSA.Expression epilogue, + ResultOperation resultOperation) { + Assert.NotNullItems(statements); - if (statements.Count == 0) { + int count = statements.Count + (prologue != null ? 1 : 0) + (epilogue != null ? 1 : 0); + if (count == 0) { + if (resultOperation.IsIgnore) { return Ast.Empty(); } else if (resultOperation.Variable != null) { @@ -622,8 +634,15 @@ return AstUtils.Return(Ast.Null(), SourceSpan.None); } - } else if (statements.Count == 1) { + } else if (count == 1) { + if (prologue != null) { + return prologue; + } + if (epilogue != null) { + return epilogue; + } + if (resultOperation.IsIgnore) { return statements[0].Transform(this); } else { @@ -631,19 +650,32 @@ } } else { - MSA.Expression[] result = new MSA.Expression[statements.Count]; + var result = new MSA.Expression[count]; + int resultIndex = 0; + if (prologue != null) { + result[resultIndex++] = prologue; + } + // transform all but the last statement if it is an expression stmt: for (int i = 0; i < statements.Count - 1; i++) { - result[i] = statements[i].Transform(this); + result[resultIndex++] = statements[i].Transform(this); } - if (resultOperation.IsIgnore) { - result[result.Length - 1] = statements[statements.Count - 1].Transform(this); - } else { - result[result.Length - 1] = statements[statements.Count - 1].TransformResult(this, resultOperation); + if (statements.Count > 0) { + if (resultOperation.IsIgnore) { + result[resultIndex++] = statements[statements.Count - 1].Transform(this); + } else { + result[resultIndex++] = statements[statements.Count - 1].TransformResult(this, resultOperation); + } } + if (epilogue != null) { + result[resultIndex++] = epilogue; + } + + Debug.Assert(resultIndex == result.Length); + return Ast.Block(new ReadOnlyCollection(result)); } } =================================================================== edit: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/AstFactory.cs;C601093 File: AstFactory.cs =================================================================== --- $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/AstFactory.cs;C601093 (server) 10/17/2008 12:59 PM +++ Shelved Change: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/AstFactory.cs;Blocks @@ -99,23 +99,39 @@ return AstUtils.Infinite(Ast.Block(body), @break, @continue); } - public static MSA.Expression/*!*/ Block(IList/*!*/ expressions) { + public static MSA.Expression[]/*!*/ CreateExpressionArray(int count) { + return (count > 0) ? new MSA.Expression[count] : EmptyExpressions; + } + + public static MSA.Expression/*!*/ Block(List/*!*/ expressions) { switch (expressions.Count) { case 0: return Ast.Empty(); case 1: return expressions[0]; + default: return Ast.Block(new ReadOnlyCollection(expressions.ToArray())); + } + } + + public static MSA.Expression/*!*/ Block(MSA.Expression/*!*/[]/*!*/ expressions) { + switch (expressions.Length) { + case 0: return Ast.Empty(); + case 1: return expressions[0]; default: return Ast.Block(new ReadOnlyCollection(expressions)); } } public static MSA.Expression/*!*/ Comma(params MSA.Expression/*!*/[]/*!*/ expressions) { - return Comma((IList)expressions); + switch (expressions.Length) { + case 0: return Ast.Empty(); + case 1: return expressions[0]; + default: return Ast.Comma(new ReadOnlyCollection(expressions)); + } } - public static MSA.Expression/*!*/ Comma(IList/*!*/ expressions) { + public static MSA.Expression/*!*/ Comma(List/*!*/ expressions) { switch (expressions.Count) { case 0: return Ast.Empty(); case 1: return expressions[0]; - default: return Ast.Comma(new ReadOnlyCollection(expressions)); + default: return Ast.Comma(new ReadOnlyCollection(expressions.ToArray())); } } =================================================================== edit: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/BlockDefinition.cs;C601093 File: BlockDefinition.cs =================================================================== --- $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/BlockDefinition.cs;C601093 (server) 10/17/2008 12:59 PM +++ Shelved Change: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/BlockDefinition.cs;Blocks @@ -15,6 +15,7 @@ using System.Collections.Generic; using System.Scripting; +using System.Diagnostics; using IronRuby.Builtins; using IronRuby.Runtime; using IronRuby.Runtime.Calls; @@ -118,7 +119,7 @@ int firstStatementLine = _body.Count > 0 ? _body[0].Location.Start.Line : Location.End.Line; - MSA.Expression paramInit = AstFactory.Block(MakeParametersInitialization(gen, parameters)); + MSA.Expression paramInit = MakeParametersInitialization(gen, parameters); MSA.Expression blockUnwinder = scope.DefineHiddenVariable("#unwinder", typeof(BlockUnwinder)); MSA.Expression body = Ast.Block( @@ -165,28 +166,34 @@ ); } - private List/*!*/ MakeParametersInitialization(AstGenerator/*!*/ gen, MSA.Expression[]/*!*/ parameters) { + private MSA.Expression/*!*/ MakeParametersInitialization(AstGenerator/*!*/ gen, MSA.Expression[]/*!*/ parameters) { Assert.NotNull(gen); Assert.NotNullItems(parameters); + var result = AstFactory.CreateExpressionArray( + _parameters.LeftValues.Count + + (_parameters.UnsplattedValue != null ? 1 : 0) + ); + + int resultIndex = 0; + bool paramsInArray = HasFormalParametersInArray; - var result = new List(); - for (int i = 0; i < _parameters.LeftValues.Count; i++) { var parameter = paramsInArray ? Ast.ArrayAccess(parameters[HiddenParameterCount], Ast.Constant(i)) : parameters[HiddenParameterCount + i]; - result.Add(_parameters.LeftValues[i].TransformWrite(gen, parameter)); + result[resultIndex++] = _parameters.LeftValues[i].TransformWrite(gen, parameter); } if (_parameters.UnsplattedValue != null) { // the last parameter is unsplat: var parameter = parameters[parameters.Length - 1]; - result.Add(_parameters.UnsplattedValue.TransformWrite(gen, parameter)); + result[resultIndex++] = _parameters.UnsplattedValue.TransformWrite(gen, parameter); } - return result; + Debug.Assert(resultIndex == result.Length); + return AstFactory.Block(result); } } } =================================================================== edit: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/SourceUnitTree.cs;C601093 File: SourceUnitTree.cs =================================================================== --- $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/SourceUnitTree.cs;C601093 (server) 10/17/2008 12:59 PM +++ Shelved Change: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/SourceUnitTree.cs;Blocks @@ -63,7 +63,6 @@ Debug.Assert(gen != null); ScopeBuilder scope = new ScopeBuilder(); - List body = new List(); MSA.ParameterExpression[] parameters; MSA.Expression selfVariable; @@ -71,7 +70,6 @@ MSA.Expression parentScope; MSA.Expression language; MSA.Expression runtimeScopeVariable; - MSA.Expression rfcTemp; MSA.Expression moduleVariable; MSA.Expression blockParameter; MSA.Expression currentMethodVariable; @@ -96,7 +94,6 @@ parentScope = null; } - rfcTemp = null; language = null; } else { parameters = new MSA.ParameterExpression[2]; @@ -105,7 +102,6 @@ selfVariable = scope.DefineHiddenVariable("#self", typeof(object)); rfcVariable = scope.DefineHiddenVariable("#rfc", typeof(RuntimeFlowControl)); - rfcTemp = scope.DefineHiddenVariable("#rfc_nonlifted", typeof(RuntimeFlowControl)); // TODO: DLR bug runtimeScopeVariable = scope.DefineHiddenVariable("#scope", typeof(RubyScope)); blockParameter = null; currentMethodVariable = null; @@ -136,32 +132,31 @@ scopeFactoryCall = null; } } else if (!gen.CompilerOptions.IsIncluded) { - scopeFactoryCall = Methods.CreateMainTopLevelScope.OpCall(scope.VisibleVariables(), parentScope, language, selfVariable, rfcTemp); + scopeFactoryCall = Methods.CreateMainTopLevelScope.OpCall(scope.VisibleVariables(), parentScope, language, selfVariable, rfcVariable); } else if (gen.CompilerOptions.IsWrapped) { - scopeFactoryCall = Methods.CreateWrappedTopLevelScope.OpCall(scope.VisibleVariables(), parentScope, language, selfVariable, rfcTemp); + scopeFactoryCall = Methods.CreateWrappedTopLevelScope.OpCall(scope.VisibleVariables(), parentScope, language, selfVariable, rfcVariable); } else { - scopeFactoryCall = Methods.CreateTopLevelScope.OpCall(scope.VisibleVariables(), parentScope, language, selfVariable, rfcTemp); + scopeFactoryCall = Methods.CreateTopLevelScope.OpCall(scope.VisibleVariables(), parentScope, language, selfVariable, rfcVariable); } + MSA.Expression prologue, body; + if (scopeFactoryCall != null) { - body.Add(Ast.Assign(runtimeScopeVariable, scopeFactoryCall)); - - if (rfcTemp != null) { - body.Add(Ast.Assign(rfcVariable, rfcTemp)); - } + prologue = Ast.Assign(runtimeScopeVariable, scopeFactoryCall); + } else { + prologue = null; } if (gen.SourceUnit.Kind == SourceCodeKind.InteractiveCode) { - MSA.Expression resultVariable = scope.DefineHiddenVariable("#result", typeof(object)); + var resultVariable = scope.DefineHiddenVariable("#result", typeof(object)); - body.Add(gen.TransformStatements(_statements, ResultOperation.Store(resultVariable))); - - body.Add(Methods.PrintInteractiveResult.OpCall(runtimeScopeVariable, + var epilogue = Methods.PrintInteractiveResult.OpCall(runtimeScopeVariable, Ast.Dynamic(RubySites.InstanceCallAction("inspect"), typeof(object), gen.CurrentScopeVariable, resultVariable) - )); + ); + body = gen.TransformStatements(prologue, _statements, epilogue, ResultOperation.Store(resultVariable)); } else { - body.Add(gen.TransformStatements(_statements, ResultOperation.Return)); + body = gen.TransformStatements(prologue, _statements, ResultOperation.Return); } gen.LeaveSourceUnit(); @@ -170,7 +165,7 @@ RubyExceptionData.TopLevelMethodName, parameters, typeof(object), - scope.CreateScope(AstFactory.Block(body)), + scope.CreateScope(body), MSA.Expression.Annotate(gen.SourceUnit.Information) ); } =================================================================== edit: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/Clauses/RescueClause.cs;C601093 File: RescueClause.cs =================================================================== --- $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/Clauses/RescueClause.cs;C601093 (server) 10/17/2008 12:59 PM +++ Shelved Change: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/Clauses/RescueClause.cs;Blocks @@ -94,17 +94,17 @@ condition = Methods.CompareDefaultException.OpCall(gen.CurrentScopeVariable, gen.CurrentSelfVariable); } - MSA.Expression transformedBody = gen.TransformStatements(_statements, resultOperation); - - if (_target != null) { - // = e; - transformedBody = Ast.Block( - _target.TransformWrite(gen, Methods.GetCurrentException.OpCall(gen.CurrentScopeVariable)), - transformedBody - ); - } + return AstUtils.IfCondition(condition, + gen.TransformStatements( + // = e; + (_target != null) ? _target.TransformWrite(gen, Methods.GetCurrentException.OpCall(gen.CurrentScopeVariable)) : null, - return AstUtils.IfCondition(condition, transformedBody); + // body: + _statements, + + resultOperation + ) + ); } private MSA.Expression/*!*/ MakeCompareException(AstGenerator/*!*/ gen, MSA.Expression/*!*/ expression) { =================================================================== edit: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/LeftValues/CompoundLeftValue.cs;C601093 File: CompoundLeftValue.cs =================================================================== --- $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/LeftValues/CompoundLeftValue.cs;C601093 (server) 10/17/2008 12:59 PM +++ Shelved Change: $/Dev10/feature/vsl_dynamic/Merlin/Main/Languages/Ruby/Ruby/Compiler/Ast/LeftValues/CompoundLeftValue.cs;Blocks @@ -82,8 +82,6 @@ private MSA.Expression/*!*/ TransformWrite(AstGenerator/*!*/ gen, List/*!*/ rightValues, MSA.Expression splattedValue) { - List writes = new List(); - // We need to distinguish various special cases here. // Each of the bool variables defined below is true iff the corresponding special form of LHS/RHS occurs. // These flags drive the DLR AST being produced by this method. @@ -147,8 +145,20 @@ optimizeReads = !rightNoneSplat; } + int writesCount = _leftValues.Count + (_unsplattedValue != null ? 1 : 0); + if (writesCount == 0) { + return resultExpression; + } + + var writes = new MSA.Expression[ + 1 + // store result to a temp + writesCount + + 1 // load from the temp + ]; + + int writeIndex = 0; MSA.Expression result = gen.CurrentScope.DefineHiddenVariable("#rhs", typeof(List)); - writes.Add(Ast.Assign(result, resultExpression)); + writes[writeIndex++] = Ast.Assign(result, resultExpression); MethodInfo itemGetter = typeof(List).GetMethod("get_Item"); for (int i = 0; i < _leftValues.Count; i++) { @@ -169,7 +179,7 @@ rvalue = Methods.GetArrayItem.OpCall(result, Ast.Constant(i)); } - writes.Add(_leftValues[i].TransformWrite(gen, rvalue)); + writes[writeIndex++] = _leftValues[i].TransformWrite(gen, rvalue); } // unsplatting the rest of rhs values into an array: @@ -179,15 +189,13 @@ MSA.Expression array = Methods.GetArraySuffix.OpCall(result, Ast.Constant(_leftValues.Count)); // assign the array (possibly empty) to *LHS: - writes.Add(_unsplattedValue.TransformWrite(gen, array)); + writes[writeIndex++] = _unsplattedValue.TransformWrite(gen, array); } - if (writes.Count == 1) { - return writes[0]; - } + writes[writeIndex++] = result; - writes.Add(result); - return AstFactory.Comma(new ReadOnlyCollection(writes)); + Debug.Assert(writes.Length == writeIndex); + return AstFactory.Comma(writes); } internal BlockSignatureAttributes GetBlockSignatureAttributes() { ===================================================================