AspectSharp/AspectSharp.Lang/Steps/Types/ResolveTypesStep.cs

   1 using AspectSharp.Lang.AST.Visitors;
   2 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15
  16 namespace AspectSharp.Lang.Steps.Types
  17 {
  18         using System;
  19         using System.IO;
  20         using System.Reflection;
  21         using System.Collections;
  22
  23         using AspectSharp.Lang.AST;
  24         using AspectSharp.Lang.Steps.Types.Resolution;
  25
  26         /// <summary>
  27         /// Summary description for ResolveTypesStep.
  28         /// </summary>
  29         public class ResolveTypesStep : AbstractVisitorStep
  30         {
  31                 private TypeManager _typeManager;
  32                 private IDictionary _mixinKey2TypeReference;
  33                 private IDictionary _interceptorKey2TypeReference;
  34
  35                 public ResolveTypesStep()
  36                 {
  37                         _typeManager = new TypeManager();
  38                         _typeManager.InspectAppDomainAssemblies();
  39
  40                         _mixinKey2TypeReference = new Hashtable();
  41                         _interceptorKey2TypeReference = new Hashtable();
  42                 }
  43
  44                 public override void Process(Context context, EngineConfiguration conf)
  45                 {
  46                         Init(context);
  47                         Visit(conf);
  48
  49                         if (!context.HasErrors)
  50                         {
  51                                 base.Process(context, conf);
  52                         }
  53                 }
  54
  55                 #region AbstractVisitorStep overrides
  56
  57                 public override void OnAssemblyReference(AssemblyReference assemblyReference)
  58                 {
  59                         try
  60                         {
  61                                 Assembly assembly;
  62                                 try
  63                                 {
  64                                         assembly = Assembly.Load(assemblyReference.AssemblyName);
  65                 }
  66                 catch(FileNotFoundException)
  67                 {
  68                     assembly = GacHelper.FindAssembly(assemblyReference.AssemblyName);
  69                 }
  70                                 assemblyReference.ResolvedAssembly = assembly;
  71                         }
  72                         catch(Exception ex)
  73                         {
  74                                 Context.RaiseErrorEvent(
  75                                         assemblyReference.LexicalInfo,
  76                                         String.Format("Could not load assembly '{0}'. Reason '{1}'",
  77                                         assemblyReference.AssemblyName, ex.Message) );
  78                         }
  79                 }
  80
  81                 public override void OnTypeReferenceDefinition(TypeReference type)
  82                 {
  83                         if (type.TargetType == TargetTypeEnum.Type)
  84                         {
  85                                 base.OnTypeReferenceDefinition (type);
  86
  87                                 if (type.AssemblyReference == null)
  88                                 {
  89                                         type.ResolvedType = _typeManager.ResolveType( type.TypeName );
  90                                 }
  91                                 else
  92                                 {
  93                                         type.ResolvedType = LoadType(
  94                                                 type.TypeName,
  95                                                 type.AssemblyReference.ResolvedAssembly.FullName,
  96                                                 type.LexicalInfo );
  97                                 }
  98                         }
  99                 }
 100
 101                 public override void OnImportDirective(ImportDirective import)
 102                 {
 103                         base.OnImportDirective (import);
 104
 105                         if (import.AssemblyReference != null)
 106                         {
 107                                 _typeManager.AddAssembly( import.AssemblyReference.ResolvedAssembly );
 108                         }
 109                 }
 110
 111                 public override void OnInterceptorEntryDefinition(InterceptorEntryDefinition interceptor)
 112                 {
 113                         base.OnInterceptorEntryDefinition (interceptor);
 114                         _interceptorKey2TypeReference[interceptor.Key] = interceptor.TypeReference;
 115                 }
 116
 117                 public override void OnMixinEntryDefinition(MixinEntryDefinition mixin)
 118                 {
 119                         base.OnMixinEntryDefinition (mixin);
 120                         _mixinKey2TypeReference[mixin.Key] = mixin.TypeReference;
 121                 }
 122
 123                 public override void OnMixinDefinition(MixinDefinition mixin)
 124                 {
 125                         if (mixin.TypeReference.TargetType == TargetTypeEnum.Type)
 126                         {
 127                                 base.OnMixinDefinition(mixin);
 128                         }
 129                         else
 130                         {
 131                                 mixin.TypeReference =
 132                                         _mixinKey2TypeReference[ mixin.TypeReference.LinkRef ] as TypeReference;
 133                         }
 134                 }
 135
 136                 public override void OnInterceptorDefinition(InterceptorDefinition interceptor)
 137                 {
 138                         if (interceptor.TypeReference.TargetType == TargetTypeEnum.Type)
 139                         {
 140                                 base.OnInterceptorDefinition(interceptor);
 141                         }
 142                         else
 143                         {
 144                                 interceptor.TypeReference =
 145                                         _interceptorKey2TypeReference[ interceptor.TypeReference.LinkRef ] as TypeReference;
 146                         }
 147                 }
 148
 149                 #endregion
 150
 151                 private Type LoadType( String typeName, String assemblyName, LexicalInfo info )
 152                 {
 153                         String qualifiedName = String.Format("{0}, {1}", typeName, assemblyName);
 154
 155                         try
 156                         {
 157                                 return Type.GetType( qualifiedName, true, false );
 158                         }
 159                         catch(Exception)
 160                         {
 161                                 Context.RaiseErrorEvent( info, "Could not load type specified " + qualifiedName );
 162                         }
 163
 164                         return null;
 165                 }
 166         }
 167 }