src/Boo.Lang.Compiler/TypeSystem/AnonymousCallablesManager.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.TypeSystem
  30 {
  31         using System;
  32         using System.Collections.Generic;
  33         using Boo.Lang.Compiler.Ast;
  34         using Module = Boo.Lang.Compiler.Ast.Module;
  35
  36         internal class AnonymousCallablesManager
  37         {
  38                 private TypeSystemServices _tss;
  39                 private IDictionary<CallableSignature, AnonymousCallableType> _cache = new Dictionary<CallableSignature, AnonymousCallableType>();
  40                 private BooCodeBuilder _codeBuilder;
  41
  42                 public AnonymousCallablesManager(TypeSystemServices tss)
  43                 {
  44                         _tss = tss;
  45                         _codeBuilder = new BooCodeBuilder(tss);
  46                 }
  47
  48                 protected TypeSystemServices TypeSystemServices
  49                 {
  50                         get { return _tss; }
  51                 }
  52
  53                 protected BooCodeBuilder CodeBuilder
  54                 {
  55                         get { return _codeBuilder; }
  56                 }
  57
  58                 public AnonymousCallableType GetCallableType(IMethod method)
  59                 {
  60                         CallableSignature signature = new CallableSignature(method);
  61                         return GetCallableType(signature);
  62                 }
  63
  64                 public AnonymousCallableType GetCallableType(CallableSignature signature)
  65                 {
  66                         AnonymousCallableType type = GetCachedCallableType(signature);
  67
  68                         if (type == null)
  69                         {
  70                                 type = new AnonymousCallableType(TypeSystemServices, signature);
  71                                 _cache.Add(signature, type);
  72                         }
  73                         return type;
  74                 }
  75
  76                 private AnonymousCallableType GetCachedCallableType(CallableSignature signature)
  77                 {
  78                         AnonymousCallableType result = null;
  79                         _cache.TryGetValue(signature, out result);
  80                         return result;
  81                 }
  82
  83                 public IType GetConcreteCallableType(Node sourceNode, CallableSignature signature)
  84                 {
  85                         AnonymousCallableType type = GetCallableType(signature);
  86                         return GetConcreteCallableType(sourceNode, type);
  87                 }
  88
  89                 public IType GetConcreteCallableType(Node sourceNode, AnonymousCallableType anonymousType)
  90                 {
  91                         if (null == anonymousType.ConcreteType)
  92                         {
  93                                 anonymousType.ConcreteType = CreateConcreteCallableType(sourceNode, anonymousType);
  94                         }
  95                         return anonymousType.ConcreteType;
  96                 }
  97
  98                 private IType CreateConcreteCallableType(Node sourceNode, AnonymousCallableType anonymousType)
  99                 {
 100                         Module module = TypeSystemServices.GetCompilerGeneratedTypesModule();
 101
 102                         TypeMember enclosing = (sourceNode.GetAncestor(NodeType.ClassDefinition) ?? sourceNode.GetAncestor(NodeType.Module)) as TypeMember;
 103                         string prefix = "__$";
 104                         string postfix = "$__";
 105                         if(enclosing != null)
 106                         {
 107                                 prefix += enclosing.Name + "$";
 108                         }
 109                         else if (!sourceNode.LexicalInfo.Equals(LexicalInfo.Empty))
 110                         {
 111                                 prefix += System.IO.Path.GetFileNameWithoutExtension(sourceNode.LexicalInfo.FileName) + "$";
 112                         }
 113                         if(!sourceNode.LexicalInfo.Equals(LexicalInfo.Empty))
 114                         {
 115                                 postfix = "$" + sourceNode.LexicalInfo.Line + "_" + sourceNode.LexicalInfo.Column + postfix;
 116                         }
 117                         string name = prefix + "callable" + module.Members.Count + postfix;
 118                         ClassDefinition cd = TypeSystemServices.CreateCallableDefinition(name);
 119                         cd.Modifiers |= TypeMemberModifiers.Public;
 120                         cd.LexicalInfo = sourceNode.LexicalInfo;
 121
 122                         cd.Members.Add(CreateInvokeMethod(anonymousType));
 123
 124                         Method beginInvoke = CreateBeginInvokeMethod(anonymousType);
 125                         cd.Members.Add(beginInvoke);
 126
 127                         cd.Members.Add(CreateEndInvokeMethod(anonymousType));
 128                         module.Members.Add(cd);
 129
 130                         CreateCallableTypeBeginInvokeExtensions(anonymousType, beginInvoke);
 131
 132                         return (IType)cd.Entity;
 133                 }
 134
 135                 private void CreateCallableTypeBeginInvokeExtensions(AnonymousCallableType anonymousType, Method beginInvoke)
 136                 {
 137                         ClassDefinition extensions = TypeSystemServices.GetCompilerGeneratedExtensionsClass();
 138                         extensions.Members.Add(CreateBeginInvokeCallbackOnlyExtension(anonymousType, beginInvoke));
 139                         extensions.Members.Add(CreateBeginInvokeSimplerExtension(anonymousType, beginInvoke));
 140                 }
 141
 142                 Method CreateBeginInvokeMethod(ICallableType anonymousType)
 143                 {
 144                         Method method = CodeBuilder.CreateRuntimeMethod("BeginInvoke", TypeSystemServices.Map(typeof(IAsyncResult)),
 145                                                                                                                         anonymousType.GetSignature().Parameters, false);
 146
 147                         int delta = method.Parameters.Count;
 148                         method.Parameters.Add(
 149                                         CodeBuilder.CreateParameterDeclaration(delta + 1, "callback", TypeSystemServices.Map(typeof(AsyncCallback))));
 150                         method.Parameters.Add(
 151                                         CodeBuilder.CreateParameterDeclaration(delta + 1, "asyncState", TypeSystemServices.ObjectType));
 152                         return method;
 153                 }
 154
 155                 Method CreateBeginInvokeExtension(ICallableType anonymousType, Method beginInvoke, out MethodInvocationExpression mie)
 156                 {
 157                         InternalMethod beginInvokeEntity = (InternalMethod)beginInvoke.Entity;
 158
 159                         Method extension = CodeBuilder.CreateMethod("BeginInvoke", TypeSystemServices.Map(typeof(IAsyncResult)),
 160                                                                                 TypeMemberModifiers.Public | TypeMemberModifiers.Static);
 161                         extension.Attributes.Add(CodeBuilder.CreateAttribute(Types.BooExtensionAttribute));
 162                         if (MetadataUtil.HasClrExtensions())
 163                         {
 164                                 extension.Attributes.Add(CodeBuilder.CreateAttribute(Types.ClrExtensionAttribute));
 165                         }
 166
 167                         ParameterDeclaration self = CodeBuilder.CreateParameterDeclaration(0, "self", beginInvokeEntity.DeclaringType);
 168
 169                         extension.Parameters.Add(self);
 170                         CodeBuilder.DeclareParameters(extension, 1, anonymousType.GetSignature().Parameters);
 171
 172                         mie = CodeBuilder.CreateMethodInvocation(
 173                                                 CodeBuilder.CreateReference(self),
 174                                                 beginInvokeEntity);
 175
 176                         ParameterDeclarationCollection parameters = extension.Parameters;
 177                         for (int i = 1; i < parameters.Count; ++i)
 178                         {
 179                                 mie.Arguments.Add(CodeBuilder.CreateReference(parameters[i]));
 180                         }
 181                         extension.Body.Add(new ReturnStatement(mie));
 182                         return extension;
 183                 }
 184
 185                 Method CreateBeginInvokeSimplerExtension(ICallableType anonymousType, Method beginInvoke)
 186                 {
 187                         MethodInvocationExpression mie;
 188                         Method overload = CreateBeginInvokeExtension(anonymousType, beginInvoke, out mie);
 189
 190                         mie.Arguments.Add(CodeBuilder.CreateNullLiteral());
 191                         mie.Arguments.Add(CodeBuilder.CreateNullLiteral());
 192
 193                         return overload;
 194                 }
 195
 196                 Method CreateBeginInvokeCallbackOnlyExtension(ICallableType anonymousType, Method beginInvoke)
 197                 {
 198                         MethodInvocationExpression mie;
 199
 200                         Method overload = CreateBeginInvokeExtension(anonymousType, beginInvoke, out mie);
 201                         ParameterDeclaration callback = CodeBuilder.CreateParameterDeclaration(overload.Parameters.Count,
 202                                                                                 "callback", TypeSystemServices.Map(typeof(AsyncCallback)));
 203                         overload.Parameters.Add(callback);
 204
 205                         mie.Arguments.Add(CodeBuilder.CreateReference(callback));
 206                         mie.Arguments.Add(CodeBuilder.CreateNullLiteral());
 207
 208                         return overload;
 209                 }
 210
 211                 public Method CreateEndInvokeMethod(ICallableType anonymousType)
 212                 {
 213                         CallableSignature signature = anonymousType.GetSignature();
 214                         Method method = CodeBuilder.CreateRuntimeMethod("EndInvoke", signature.ReturnType);
 215
 216                         int delta = 1;
 217                         foreach (IParameter p in signature.Parameters)
 218                         {
 219                                 if (p.IsByRef)
 220                                 {
 221                                         method.Parameters.Add(
 222                                                 CodeBuilder.CreateParameterDeclaration(++delta,
 223                                                                 p.Name,
 224                                                                 p.Type,
 225                                                                 true));
 226                                 }
 227                         }
 228                         delta = method.Parameters.Count;
 229                         method.Parameters.Add(
 230                                 CodeBuilder.CreateParameterDeclaration(delta + 1, "result", TypeSystemServices.Map(typeof(IAsyncResult))));
 231                         return method;
 232                 }
 233
 234                 Method CreateInvokeMethod(AnonymousCallableType anonymousType)
 235                 {
 236                         CallableSignature signature = anonymousType.GetSignature();
 237                         return CodeBuilder.CreateRuntimeMethod("Invoke", signature.ReturnType, signature.Parameters, signature.AcceptVarArgs);
 238                 }
 239         }
 240 }
 241