src/Boo.Lang.Compiler/Steps/ProcessClosures.cs

   1 #region license
   2 // Copyright (c) 2004, Rodrigo B. de Oliveira (rbo@acm.org)
   3 // All rights reserved.
   4 //
   5 // Redistribution and use in source and binary forms, with or without modification,
   6 // are permitted provided that the following conditions are met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright notice,
   9 //     this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above copyright notice,
  11 //     this list of conditions and the following disclaimer in the documentation
  12 //     and/or other materials provided with the distribution.
  13 //     * Neither the name of Rodrigo B. de Oliveira nor the names of its
  14 //     contributors may be used to endorse or promote products derived from this
  15 //     software without specific prior written permission.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  18 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  21 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  24 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  25 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27 #endregion
  28
  29 namespace Boo.Lang.Compiler.Steps
  30 {
  31         using Boo.Lang.Compiler.Ast;
  32         using Boo.Lang.Compiler.TypeSystem;
  33
  34         public class ProcessClosures : AbstractTransformerCompilerStep
  35         {
  36                 override public void Run()
  37                 {
  38                         Visit(CompileUnit);
  39                 }
  40
  41                 override public void LeaveBlockExpression(BlockExpression node)
  42                 {
  43                         InternalMethod closureEntity = (InternalMethod)GetEntity(node);
  44
  45                         using (ForeignReferenceCollector collector = new ForeignReferenceCollector())
  46                         {
  47                                 collector.CurrentMethod = closureEntity.Method;
  48                                 collector.CurrentType = (IType)closureEntity.DeclaringType;
  49                                 collector.Initialize(_context);
  50                                 collector.Visit(closureEntity.Method.Body);
  51
  52                                 if (collector.ContainsForeignLocalReferences)
  53                                 {
  54                                         BooClassBuilder closureClass = CreateClosureClass(collector, closureEntity);
  55                                         closureClass.ClassDefinition.LexicalInfo = node.LexicalInfo;
  56                                         collector.AdjustReferences();
  57
  58                                         ReplaceCurrentNode(
  59                                                 CodeBuilder.CreateMemberReference(
  60                                                         collector.CreateConstructorInvocationWithReferencedEntities(
  61                                                                 closureClass.Entity),
  62                                                         closureEntity));
  63                                 }
  64                                 else
  65                                 {
  66                                         Expression expression = CodeBuilder.CreateMemberReference(closureEntity);
  67                                         expression.LexicalInfo = node.LexicalInfo;
  68                                         TypeSystemServices.GetConcreteExpressionType(expression);
  69                                         ReplaceCurrentNode(expression);
  70                                 }
  71                         }
  72                 }
  73
  74                 BooClassBuilder CreateClosureClass(ForeignReferenceCollector collector, InternalMethod closure)
  75                 {
  76                         Method method = closure.Method;
  77                         TypeDefinition parent = method.DeclaringType;
  78                         parent.Members.Remove(method);
  79
  80                         BooClassBuilder builder = collector.CreateSkeletonClass(closure.Name, method.LexicalInfo);
  81                         parent.Members.Add(builder.ClassDefinition);
  82                         builder.ClassDefinition.Members.Add(method);
  83                         method.Name = "Invoke";
  84
  85                         if (method.IsStatic)
  86                         {
  87                                 // need to adjust paremeter indexes (parameter 0 is now self)
  88                                 foreach (ParameterDeclaration parameter in method.Parameters)
  89                                 {
  90                                         ((InternalParameter)parameter.Entity).Index += 1;
  91                                 }
  92                         }
  93
  94                         method.Modifiers = TypeMemberModifiers.Public;
  95                         return builder;
  96                 }
  97         }
  98 }