src/Boo.Lang.Compiler/Steps/BindBaseTypes.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 System;
  32         using Boo.Lang.Compiler.Ast;
  33         using Boo.Lang.Compiler;
  34         using Boo.Lang.Compiler.TypeSystem;
  35
  36         [Serializable]
  37         public class BindBaseTypes : AbstractNamespaceSensitiveVisitorCompilerStep
  38         {
  39                 public BindBaseTypes()
  40                 {
  41                 }
  42
  43                 override public void Run()
  44                 {
  45                         Visit(CompileUnit.Modules);
  46                 }
  47
  48                 override public void OnEnumDefinition(EnumDefinition node)
  49                 {
  50                 }
  51
  52                 override public void OnClassDefinition(ClassDefinition node)
  53                 {
  54                         // Visit type definition's members to resolve base types on nested types
  55                         base.OnClassDefinition(node);
  56
  57                         // Resolve and check base types
  58                         ResolveBaseTypes(new Boo.Lang.List(), node);
  59                         CheckBaseTypes(node);
  60
  61                         if (!node.IsFinal)
  62                         {
  63                                 if (((IType)node.Entity).IsFinal)
  64                                 {
  65                                         node.Modifiers |= TypeMemberModifiers.Final;
  66                                 }
  67                         }
  68                 }
  69
  70                 override public void OnInterfaceDefinition(InterfaceDefinition node)
  71                 {
  72                         ResolveBaseTypes(new Boo.Lang.List(), node);
  73                         CheckInterfaceBaseTypes(node);
  74                 }
  75
  76                 void CheckBaseTypes(ClassDefinition node)
  77                 {
  78                         IType baseClass = null;
  79                         foreach (TypeReference baseType in node.BaseTypes)
  80                         {
  81                                 IType baseInfo = GetType(baseType);
  82                                 if (!baseInfo.IsInterface)
  83                                 {
  84                                         if (null != baseClass)
  85                                         {
  86                                                 Error(
  87                                                     CompilerErrorFactory.ClassAlreadyHasBaseType(baseType,
  88                                                                 node.Name,
  89                                                                 baseClass.FullName)
  90                                                         );
  91                                         }
  92                                         else
  93                                         {
  94                                                 baseClass = baseInfo;
  95                                                 if (baseClass.IsFinal && !TypeSystemServices.IsError(baseClass))
  96                                                 {
  97                                                         Error(
  98                                                                 CompilerErrorFactory.CannotExtendFinalType(
  99                                                                         baseType,
 100                                                                         baseClass.FullName));
 101                                                 }
 102                                         }
 103                                 }
 104                         }
 105
 106                         if (null == baseClass)
 107                         {
 108                                 node.BaseTypes.Insert(0, CodeBuilder.CreateTypeReference(TypeSystemServices.ObjectType) );
 109                         }
 110                 }
 111
 112                 void CheckInterfaceBaseTypes(InterfaceDefinition node)
 113                 {
 114                         foreach (TypeReference baseType in node.BaseTypes)
 115                         {
 116                                 IType tag = GetType(baseType);
 117                                 if (!tag.IsInterface)
 118                                 {
 119                                         Error(CompilerErrorFactory.InterfaceCanOnlyInheritFromInterface(baseType, node.FullName, tag.FullName));
 120                                 }
 121                         }
 122                 }
 123
 124                 void ResolveBaseTypes(Boo.Lang.List visited, TypeDefinition node)
 125                 {
 126                         // If type is generic, enter a special namespace to allow
 127                         // correct resolution of generic parameters
 128                         IType type = (IType)TypeSystemServices.GetEntity(node);
 129                         if (type.GenericInfo != null)
 130                         {
 131                                 EnterNamespace(new GenericParametersNamespaceExtender(
 132                                         type, NameResolutionService.CurrentNamespace));
 133                         }
 134
 135                         visited.Add(node);
 136
 137             Boo.Lang.List visitedNonInterfaces = null;
 138             Boo.Lang.List visitedInterfaces = null;
 139
 140                         if (node is InterfaceDefinition)
 141             {
 142                 visitedInterfaces = visited;
 143                 // interfaces won't have noninterface base types so visitedNonInterfaces not necessary here
 144             }
 145             else
 146             {
 147                 visitedNonInterfaces = visited;
 148                 visitedInterfaces = new Boo.Lang.List();
 149             }
 150
 151                         int removed = 0;
 152                         int index = 0;
 153                         foreach (SimpleTypeReference baseType in node.BaseTypes.ToArray())
 154                         {
 155                                 NameResolutionService.ResolveSimpleTypeReference(baseType);
 156
 157                                 AbstractInternalType internalType = baseType.Entity as AbstractInternalType;
 158                                 if (null != internalType)
 159                                 {
 160                     if (internalType is InternalInterface)
 161                     {
 162                         if (visitedInterfaces.Contains(internalType.TypeDefinition))
 163                         {
 164                             Error(CompilerErrorFactory.InheritanceCycle(baseType, internalType.FullName));
 165                             node.BaseTypes.RemoveAt(index - removed);
 166                             ++removed;
 167                         }
 168                         else
 169                         {
 170                             ResolveBaseTypes(visitedInterfaces, internalType.TypeDefinition);
 171                         }
 172                     }
 173                     else
 174                     {
 175                         if (visitedNonInterfaces.Contains(internalType.TypeDefinition))
 176                                         {
 177                                                 Error(CompilerErrorFactory.InheritanceCycle(baseType, internalType.FullName));
 178                                                 node.BaseTypes.RemoveAt(index - removed);
 179                                                 ++removed;
 180                                         }
 181                                         else
 182                                         {
 183                             ResolveBaseTypes(visitedNonInterfaces, internalType.TypeDefinition);
 184                         }
 185                                         }
 186                                 }
 187                                 ++index;
 188                         }
 189
 190                         // Leave special namespace if we entered it before
 191                         if (type.GenericInfo != null)
 192                         {
 193                                 LeaveNamespace();
 194                         }
 195                 }
 196         }
 197
 198         /// <summary>
 199         /// Provides a quasi-namespace that can resolve a type's generic parameters before its base types are bound.
 200         /// </summary>
 201         internal class GenericParametersNamespaceExtender : INamespace
 202         {
 203                 IType _type;
 204                 INamespace _parent;
 205
 206                 public GenericParametersNamespaceExtender(IType type, INamespace currentNamespace)
 207                 {
 208                         _type = type;
 209                         _parent = currentNamespace;
 210                 }
 211
 212                 public INamespace ParentNamespace
 213                 {
 214                         get
 215                         {
 216                                 return _parent;
 217                         }
 218                 }
 219
 220                 public bool Resolve(List targetList, string name, EntityType filter)
 221                 {
 222                         if (_type.GenericInfo != null && filter == EntityType.Type)
 223                         {
 224                                 IGenericParameter match = Array.Find(
 225                                         _type.GenericInfo.GenericParameters,
 226                                         delegate(IGenericParameter gp) { return gp.Name == name; });
 227
 228                                 if (match != null)
 229                                 {
 230                                         targetList.AddUnique(match);
 231                                         return true;
 232                                 }
 233                         }
 234                         return false;
 235                 }
 236
 237                 public IEntity[] GetMembers()
 238                 {
 239                         if (_type.GenericInfo != null)
 240                         {
 241                                 return _type.GenericInfo.GenericParameters;
 242                         }
 243                         return NullNamespace.EmptyEntityArray;
 244                 }
 245         }
 246 }