src/Boo.Lang.Compiler/Steps/ForeignReferenceCollector.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 using System;
  30 using Boo.Lang;
  31 using Boo.Lang.Compiler;
  32 using Boo.Lang.Compiler.Ast;
  33 using Boo.Lang.Compiler.TypeSystem;
  34
  35 namespace Boo.Lang.Compiler.Steps
  36 {
  37         public class ForeignReferenceCollector : DepthFirstVisitor, IDisposable, ICompilerComponent
  38         {
  39                 Node _sourceNode;
  40
  41                 IType _currentType;
  42
  43                 Method _currentMethod;
  44
  45                 List _references;
  46
  47                 Hash _referencedEntities;
  48
  49                 SelfEntity _selfEntity;
  50
  51                 CompilerContext _context;
  52
  53                 public ForeignReferenceCollector()
  54                 {
  55                         _references = new List();
  56                         _referencedEntities = new Hash();
  57                 }
  58
  59                 public Node SourceNode
  60                 {
  61                         get
  62                         {
  63                                 return _sourceNode;
  64                         }
  65
  66                         set
  67                         {
  68                                 _sourceNode = value;
  69                         }
  70                 }
  71
  72                 public Method CurrentMethod
  73                 {
  74                         get
  75                         {
  76                                 return _currentMethod;
  77                         }
  78
  79                         set
  80                         {
  81                                 _currentMethod = value;
  82                         }
  83                 }
  84
  85                 public IType CurrentType
  86                 {
  87                         get
  88                         {
  89                                 return _currentType;
  90                         }
  91
  92                         set
  93                         {
  94                                 _currentType = value;
  95                                 if (null != _selfEntity)
  96                                 {
  97                                         _selfEntity.Type = value;
  98                                 }
  99                         }
 100                 }
 101
 102                 public List References
 103                 {
 104                         get
 105                         {
 106                                 return _references;
 107                         }
 108                 }
 109
 110                 public Hash ReferencedEntities
 111                 {
 112                         get
 113                         {
 114                                 return _referencedEntities;
 115                         }
 116                 }
 117
 118                 public bool ContainsForeignLocalReferences
 119                 {
 120                         get
 121                         {
 122                                 foreach (IEntity entity in _referencedEntities.Keys)
 123                                 {
 124                                         EntityType type = entity.EntityType;
 125                                         if (EntityType.Local == type ||
 126                                                 EntityType.Parameter == type)
 127                                         {
 128                                                 return true;
 129                                         }
 130                                 }
 131                                 return false;
 132                         }
 133                 }
 134
 135                 protected IEntity GetSelfEntity()
 136                 {
 137                         if (null == _selfEntity)
 138                         {
 139                                 _selfEntity = new SelfEntity("this", CurrentType);
 140                         }
 141                         return _selfEntity;
 142                 }
 143
 144                 protected BooCodeBuilder CodeBuilder
 145                 {
 146                         get
 147                         {
 148                                 return _context.CodeBuilder;
 149                         }
 150                 }
 151
 152                 public void Initialize(CompilerContext context)
 153                 {
 154                         if (null == _currentType)
 155                         {
 156                                 throw new InvalidOperationException("CurrentType was not properly initialized!");
 157                         }
 158                         _context = context;
 159                 }
 160
 161                 public void Dispose()
 162                 {
 163                         _context = null;
 164                         _currentMethod = null;
 165                         _selfEntity = null;
 166                         _references.Clear();
 167                         _referencedEntities.Clear();
 168                 }
 169
 170                 public BooClassBuilder CreateSkeletonClass(string name, LexicalInfo lexicalInfo)
 171                 {
 172                         BooClassBuilder builder = CodeBuilder.CreateClass(name);
 173                         builder.Modifiers |= TypeMemberModifiers.Internal;
 174                         builder.LexicalInfo = lexicalInfo;
 175
 176                         builder.AddBaseType(CodeBuilder.TypeSystemServices.ObjectType);
 177                         DeclareFieldsAndConstructor(builder);
 178                         return builder;
 179                 }
 180
 181                 public void DeclareFieldsAndConstructor(BooClassBuilder builder)
 182                 {
 183                         // referenced entities turn into fields
 184                         foreach (ITypedEntity entity in Builtins.array(_referencedEntities.Keys))
 185                         {
 186                                 Field field = builder.AddInternalField("__" + entity.Name + _context.AllocIndex(), entity.Type);
 187                                 _referencedEntities[entity] = field.Entity;
 188                         }
 189
 190                         // single constructor taking all referenced entities
 191                         BooMethodBuilder constructor = builder.AddConstructor();
 192                         constructor.Modifiers = TypeMemberModifiers.Public;
 193                         constructor.Body.Add(CodeBuilder.CreateSuperConstructorInvocation(builder.Entity.BaseType));
 194                         foreach (ITypedEntity entity in _referencedEntities.Keys)
 195                         {
 196                                 InternalField field = (InternalField)_referencedEntities[entity];
 197                                 ParameterDeclaration parameter = constructor.AddParameter(field.Name, entity.Type);
 198                                 constructor.Body.Add(
 199                                         CodeBuilder.CreateAssignment(CodeBuilder.CreateReference(field),
 200                                                                         CodeBuilder.CreateReference(parameter)));
 201                         }
 202                 }
 203
 204                 public void AdjustReferences()
 205                 {
 206                         foreach (Expression reference in _references)
 207                         {
 208                                 InternalField entity = (InternalField)_referencedEntities[reference.Entity];
 209                                 if (null != entity)
 210                                 {
 211                                         reference.ParentNode.Replace(reference,
 212                                                         CodeBuilder.CreateReference(entity));
 213                                 }
 214                         }
 215                 }
 216
 217                 public MethodInvocationExpression CreateConstructorInvocationWithReferencedEntities(IType type)
 218                 {
 219                         MethodInvocationExpression mie = CodeBuilder.CreateConstructorInvocation(type.GetConstructors()[0]);
 220                         foreach (ITypedEntity entity in _referencedEntities.Keys)
 221                         {
 222                                 mie.Arguments.Add(CreateForeignReference(entity));
 223                         }
 224                         return mie;
 225                 }
 226
 227                 public Expression CreateForeignReference(IEntity entity)
 228                 {
 229                         if (_selfEntity == entity)
 230                         {
 231                                 return CodeBuilder.CreateSelfReference(CurrentType);
 232                         }
 233                         else
 234                         {
 235                                 return CodeBuilder.CreateReference(entity);
 236                         }
 237                 }
 238
 239                 override public void OnReferenceExpression(ReferenceExpression node)
 240                 {
 241                         if (IsForeignReference(node))
 242                         {
 243                                 _references.Add(node);
 244                                 _referencedEntities[node.Entity] = null;
 245                         }
 246                 }
 247
 248                 override public void OnSelfLiteralExpression(SelfLiteralExpression node)
 249                 {
 250                         IEntity entity = GetSelfEntity();
 251                         node.Entity = entity;
 252                         _references.Add(node);
 253                         _referencedEntities[entity] = null;
 254                 }
 255
 256                 bool IsForeignReference(ReferenceExpression node)
 257                 {
 258                         IEntity entity = node.Entity;
 259                         if (null != entity)
 260                         {
 261                                 EntityType type = entity.EntityType;
 262                                 if (type == EntityType.Local)
 263                                 {
 264                                         return null == _currentMethod ||
 265                                                 !_currentMethod.Locals.ContainsEntity(entity);
 266                                 }
 267                                 else if (type == EntityType.Parameter)
 268                                 {
 269                                         return null == _currentMethod ||
 270                                                 !_currentMethod.Parameters.ContainsEntity(entity);
 271                                 }
 272                         }
 273                         return false;
 274                 }
 275         }
 276 }