src/Boo.Lang.Compiler/Steps/InitializeNameResolutionService.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;
  32         using Boo.Lang.Compiler.Ast;
  33         using Boo.Lang.Compiler.TypeSystem;
  34         using System;
  35         using System.Reflection;
  36         using System.Collections;
  37
  38         public class InitializeNameResolutionService : AbstractVisitorCompilerStep
  39         {
  40                 public InitializeNameResolutionService()
  41                 {
  42                 }
  43
  44                 override public void Run()
  45                 {
  46                         NameResolutionService.GlobalNamespace = new GlobalNamespace();
  47
  48                         ResolveImportAssemblyReferences();
  49
  50                         OrganizeExternalNamespaces();
  51                         ResolveInternalModules();
  52                 }
  53
  54                 void ResolveInternalModules()
  55                 {
  56                         foreach (Boo.Lang.Compiler.Ast.Module module in CompileUnit.Modules)
  57                         {
  58                                 TypeSystem.ModuleEntity moduleEntity = new TypeSystem.ModuleEntity(NameResolutionService, TypeSystemServices, module);
  59                                 module.Entity = moduleEntity;
  60
  61                                 NamespaceDeclaration namespaceDeclaration = module.Namespace;
  62                                 if (null != namespaceDeclaration)
  63                                 {
  64                                         module.Imports.Add(new Import(namespaceDeclaration.LexicalInfo, namespaceDeclaration.Name));
  65                                 }
  66                                 AddInternalModule(moduleEntity);
  67                         }
  68                         AddInternalModule((ModuleEntity) TypeSystemServices.GetCompilerGeneratedExtensionsModule().Entity);
  69                 }
  70
  71                 private void AddInternalModule(ModuleEntity moduleEntity)
  72                 {
  73                         NameResolutionService.GetNamespace(moduleEntity.Namespace).AddModule(moduleEntity);
  74                 }
  75
  76                 void ResolveImportAssemblyReferences()
  77                 {
  78                         foreach (Boo.Lang.Compiler.Ast.Module module in CompileUnit.Modules)
  79                         {
  80                                 ImportCollection imports = module.Imports;
  81                                 Import[] importArray = imports.ToArray();
  82                                 for (int i=0; i<importArray.Length; ++i)
  83                                 {
  84                                         Import u = importArray[i];
  85                                         ReferenceExpression reference = u.AssemblyReference;
  86                                         if (null != reference)
  87                                         {
  88                                                 try
  89                                                 {
  90                                                         Assembly asm = Parameters.FindAssembly(reference.Name);
  91                                                         if (null == asm)
  92                                                         {
  93                                                                 asm = Parameters.LoadAssembly(reference.Name);
  94                                                                 if (null != asm)
  95                                                                 {
  96                                                                         Parameters.AddAssembly(asm);
  97                                                                 }
  98                                                         }
  99                                                         reference.Entity = new TypeSystem.AssemblyReference(asm);
 100                                                 }
 101                                                 catch (Exception x)
 102                                                 {
 103                                                         Errors.Add(CompilerErrorFactory.UnableToLoadAssembly(reference, reference.Name, x));
 104                                                         imports.RemoveAt(i);
 105                                                 }
 106                                         }
 107                                 }
 108                         }
 109                 }
 110
 111                 void OrganizeExternalNamespaces()
 112                 {
 113                         foreach (Assembly asm in Parameters.References)
 114                         {
 115                                 try
 116                                 {
 117                                         NameResolutionService.OrganizeAssemblyTypes(asm);
 118                                 }
 119                                 catch (ReflectionTypeLoadException x)
 120                                 {
 121                                         System.IO.StringWriter loadErrors = new System.IO.StringWriter();
 122                                         loadErrors.Write("'" + asm.FullName + "' - (" + GetLocation(asm) + "):");
 123                                         loadErrors.WriteLine(x.Message);
 124                                         foreach(Exception e in x.LoaderExceptions)
 125                                         {
 126                                                 loadErrors.WriteLine(e.Message);
 127                                         }
 128                                         Errors.Add(
 129                                                 CompilerErrorFactory.FailedToLoadTypesFromAssembly(
 130                                                         loadErrors.ToString(), x));
 131                                 }
 132                                 catch (Exception x)
 133                                 {
 134                                         Errors.Add(
 135                                                 CompilerErrorFactory.FailedToLoadTypesFromAssembly(
 136                                                         "'" + asm.FullName + "' - (" + GetLocation(asm) + "): " + x.Message, x));
 137                                 }
 138                         }
 139                 }
 140
 141                 string GetLocation(Assembly asm)
 142                 {
 143                         try { return asm.Location; } catch (Exception /*ignored*/) {}
 144                         return "location unavailable";
 145                 }
 146         }
 147 }