src/Boo.Lang.Compiler/Ast/TypeMember.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
  31 namespace Boo.Lang.Compiler.Ast
  32 {
  33         [System.Xml.Serialization.XmlInclude(typeof(TypeDefinition))]
  34         [System.Xml.Serialization.XmlInclude(typeof(EnumMember))]
  35         [System.Xml.Serialization.XmlInclude(typeof(Field))]
  36         [System.Xml.Serialization.XmlInclude(typeof(Property))]
  37         [System.Xml.Serialization.XmlInclude(typeof(Method))]
  38         public abstract partial class TypeMember
  39         {
  40                 protected TypeMember()
  41                 {
  42                 }
  43
  44                 protected TypeMember(TypeMemberModifiers modifiers, string name)
  45                 {
  46                         this.Modifiers = modifiers;
  47                         this.Name = name;
  48                 }
  49
  50                 protected TypeMember(LexicalInfo lexicalInfoProvider) : base(lexicalInfoProvider)
  51                 {
  52                 }
  53
  54                 public virtual TypeDefinition DeclaringType
  55                 {
  56                         get
  57                         {
  58                                 return ParentNode as TypeDefinition;
  59                         }
  60                 }
  61
  62                 public virtual string FullName
  63                 {
  64                         get
  65                         {
  66                                 if (null != ParentNode)
  67                                 {
  68                                         return DeclaringType.FullName + "." + Name;
  69                                 }
  70                                 return Name;
  71                         }
  72                 }
  73
  74                 public virtual NamespaceDeclaration EnclosingNamespace
  75                 {
  76                         get
  77                         {
  78                                 Module enclosing = this.EnclosingModule;
  79                                 return enclosing == null ? null : enclosing.Namespace;
  80                         }
  81                 }
  82
  83                 public virtual Module EnclosingModule
  84                 {
  85                         get
  86                         {
  87                                 Node parent = _parent;
  88                                 while (parent != null)
  89                                 {
  90                                         Module module = parent as Module;
  91                                         if (null != module)
  92                                         {
  93                                                 return module;
  94                                         }
  95                                         parent = parent.ParentNode;
  96                                 }
  97                                 return null;
  98                         }
  99                 }
 100
 101                 public TypeMemberModifiers Visibility
 102                 {
 103                         get
 104                         {
 105                                 return _modifiers & TypeMemberModifiers.VisibilityMask;
 106                         }
 107
 108                         set
 109                         {
 110                                 _modifiers &= ~TypeMemberModifiers.VisibilityMask;
 111                                 _modifiers |= value;
 112                         }
 113                 }
 114
 115                 public bool IsVisibilitySet
 116                 {
 117                         get
 118                         {
 119                                 return IsPublic | IsInternal | IsPrivate | IsProtected;
 120                         }
 121                 }
 122
 123                 public bool IsAbstract
 124                 {
 125                         get
 126                         {
 127                                 return IsModifierSet(TypeMemberModifiers.Abstract);
 128                         }
 129                 }
 130
 131                 public bool IsOverride
 132                 {
 133                         get
 134                         {
 135                                 return IsModifierSet(TypeMemberModifiers.Override);
 136                         }
 137                 }
 138
 139                 public bool IsVirtual
 140                 {
 141                         get
 142                         {
 143                                 return IsModifierSet(TypeMemberModifiers.Virtual);
 144                         }
 145                 }
 146
 147                 public bool IsStatic
 148                 {
 149                         get
 150                         {
 151                                 return IsModifierSet(TypeMemberModifiers.Static);
 152                         }
 153                 }
 154
 155                 public bool IsPublic
 156                 {
 157                         get
 158                         {
 159                                 return IsModifierSet(TypeMemberModifiers.Public);
 160                         }
 161                 }
 162
 163                 public bool IsInternal
 164                 {
 165                         get
 166                         {
 167                                 return IsModifierSet(TypeMemberModifiers.Internal);
 168                         }
 169                 }
 170
 171                 public bool IsProtected
 172                 {
 173                         get
 174                         {
 175                                 return IsModifierSet(TypeMemberModifiers.Protected);
 176                         }
 177                 }
 178
 179                 public bool IsPrivate
 180                 {
 181                         get
 182                         {
 183                                 return IsModifierSet(TypeMemberModifiers.Private);
 184                         }
 185                 }
 186
 187                 public bool IsFinal
 188                 {
 189                         get
 190                         {
 191                                 return IsModifierSet(TypeMemberModifiers.Final);
 192                         }
 193                 }
 194
 195                 public bool IsTransient
 196                 {
 197                         get
 198                         {
 199                                 return IsModifierSet(TypeMemberModifiers.Transient);
 200                         }
 201                 }
 202
 203                 public bool IsPartial
 204                 {
 205                         get
 206                         {
 207                                 return IsModifierSet(TypeMemberModifiers.Partial);
 208                         }
 209                 }
 210
 211                 public bool IsModifierSet(TypeMemberModifiers modifiers)
 212                 {
 213                         return modifiers == (_modifiers & modifiers);
 214                 }
 215
 216                 override public string ToString()
 217                 {
 218                         return FullName;
 219                 }
 220         }
 221 }