src/Boo.Lang.Compiler/TypeSystem/ModuleEntity.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.Collections.Generic;
  30 using Boo.Lang.Compiler.Ast;
  31
  32 namespace Boo.Lang.Compiler.TypeSystem
  33 {
  34         public class ModuleEntity : INamespace, IEntity
  35         {
  36                 private readonly NameResolutionService _nameResolutionService;
  37
  38                 private readonly TypeSystemServices _typeSystemServices;
  39
  40                 private readonly Module _module;
  41
  42                 private ClassDefinition _moduleClass;
  43
  44                 private INamespace _moduleClassNamespace = NullNamespace.Default;
  45
  46                 private string _namespace;
  47
  48                 public ModuleEntity(NameResolutionService nameResolutionService,
  49                                                 TypeSystemServices typeSystemServices,
  50                                                 Module module)
  51                 {
  52                         _nameResolutionService = nameResolutionService;
  53                         _typeSystemServices = typeSystemServices;
  54                         _module = module;
  55                         _namespace = SafeNamespace(module);
  56                 }
  57
  58                 private static string SafeNamespace(Module module)
  59                 {
  60                         return null == module.Namespace ? string.Empty : module.Namespace.Name;
  61                 }
  62
  63                 public EntityType EntityType
  64                 {
  65                         get { return EntityType.Module; }
  66                 }
  67
  68                 public string Name
  69                 {
  70                         get { return _module.Name; }
  71                 }
  72
  73                 public string FullName
  74                 {
  75                         get { return _module.FullName; }
  76                 }
  77
  78                 public string Namespace
  79                 {
  80                         get { return _namespace; }
  81                 }
  82
  83                 public Boo.Lang.Compiler.Ast.ClassDefinition ModuleClass
  84                 {
  85                         get { return _moduleClass; }
  86                 }
  87
  88                 public void InitializeModuleClass(Boo.Lang.Compiler.Ast.ClassDefinition moduleClass)
  89                 {
  90                         _moduleClassNamespace = (INamespace) _typeSystemServices.GetMemberEntity(moduleClass);
  91                         _moduleClass = moduleClass;
  92                 }
  93
  94                 public bool ResolveMember(Boo.Lang.List targetList, string name, EntityType flags)
  95                 {
  96                         if (ResolveModuleMember(targetList, name, flags)) return true;
  97                         return _moduleClassNamespace.Resolve(targetList, name, flags);
  98                 }
  99
 100                 public INamespace ParentNamespace
 101                 {
 102                         get { return _nameResolutionService.GlobalNamespace; }
 103                 }
 104
 105                 public bool Resolve(Boo.Lang.List targetList, string name, EntityType flags)
 106                 {
 107                         if (ResolveMember(targetList, name, flags)) return true;
 108                         bool found = false;
 109                         foreach (Import import in _module.Imports)
 110                         {
 111                                 INamespace ns = (INamespace) TypeSystemServices.GetEntity(import);
 112                                 bool currentFound = ns.Resolve(targetList, name, flags);
 113                                 found |= currentFound;
 114                                 if (currentFound) import.NamespaceUsed = true;
 115                         }
 116                         return found;
 117                 }
 118
 119                 bool ResolveModuleMember(Boo.Lang.List targetList, string name, EntityType flags)
 120                 {
 121                         bool found = false;
 122                         foreach (TypeMember member in _module.Members)
 123                         {
 124                                 if (name != member.Name) continue;
 125
 126                                 IEntity entity = _typeSystemServices.GetMemberEntity(member);
 127                                 if (NameResolutionService.IsFlagSet(flags, entity.EntityType))
 128                                 {
 129                                         targetList.Add(entity);
 130                                         found = true;
 131                                 }
 132                         }
 133                         return found;
 134                 }
 135
 136                 public IEntity[] GetMembers()
 137                 {
 138                         return _moduleClassNamespace.GetMembers();
 139                 }
 140         }
 141 }