src/Boo.Lang.Compiler/Attributes/PropertyAttribute.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 using Boo.Lang.Compiler.Ast;
  31
  32 namespace Boo.Lang
  33 {
  34         /// <summary>
  35         /// Creates a property over a field.
  36         /// </summary>
  37         public class PropertyAttribute : Boo.Lang.Compiler.AbstractAstAttribute
  38         {
  39                 protected ReferenceExpression _propertyName;
  40
  41                 protected Expression _setPreCondition;
  42
  43                 protected BoolLiteralExpression _protected;
  44
  45                 protected BoolLiteralExpression _observable;
  46
  47                 protected ListLiteralExpression _attributes;
  48
  49                 public PropertyAttribute(ReferenceExpression propertyName) : this(propertyName, null)
  50                 {
  51                 }
  52
  53                 public PropertyAttribute(ReferenceExpression propertyName, Expression setPreCondition)
  54                 {
  55                         if (null == propertyName)
  56                         {
  57                                 throw new ArgumentNullException("propertyName");
  58                         }
  59                         _propertyName = propertyName;
  60                         _setPreCondition = setPreCondition;
  61                 }
  62
  63                 public BoolLiteralExpression Protected
  64                 {
  65                         get
  66                         {
  67                                 return _protected;
  68                         }
  69
  70                         set
  71                         {
  72                                 _protected = value;
  73                         }
  74                 }
  75
  76                 protected bool IsProtected
  77                 {
  78                         get
  79                         {
  80                                 if (null == _protected)
  81                                 {
  82                                         return false;
  83                                 }
  84                                 return _protected.Value;
  85                         }
  86                 }
  87
  88                 public BoolLiteralExpression Observable
  89                 {
  90                         get
  91                         {
  92                                 return _observable;
  93                         }
  94
  95                         set
  96                         {
  97                                 _observable = value;
  98                         }
  99                 }
 100
 101                 protected bool IsObservable
 102                 {
 103                         get
 104                         {
 105                                 if (null == _observable)
 106                                 {
 107                                         return false;
 108                                 }
 109                                 return _observable.Value;
 110                         }
 111                 }
 112
 113                 protected string ChangedEventName
 114                 {
 115                         get
 116                         {
 117                                 return _propertyName.Name + "Changed";
 118                         }
 119                 }
 120
 121                 public ListLiteralExpression Attributes
 122                 {
 123                         get
 124                         {
 125                                 return _attributes;
 126                         }
 127
 128                         set
 129                         {
 130                                 _attributes = value;
 131                         }
 132                 }
 133
 134                 override public void Apply(Node node)
 135                 {
 136                         Field f = node as Field;
 137                         if (null == f)
 138                         {
 139                                 InvalidNodeForAttribute("Field");
 140                                 return;
 141                         }
 142
 143                         Property p = new Property();
 144                         if (f.IsStatic)
 145                         {
 146                                 p.Modifiers |= TypeMemberModifiers.Static;
 147                         }
 148                         if (IsProtected)
 149                         {
 150                                 p.Modifiers |= TypeMemberModifiers.Protected;
 151                         }
 152                         p.Name = _propertyName.Name;
 153                         p.Type = f.Type;
 154                         p.Getter = CreateGetter(f);
 155                         p.Setter = CreateSetter(f);
 156                         p.LexicalInfo = LexicalInfo;
 157
 158                         if (Attributes != null && Attributes.Items.Count > 0)
 159                         {
 160                                 foreach (Expression item in Attributes.Items)
 161                                 {
 162                                         p.Attributes.Add(ConvertExpressionToAttribute(item));
 163                                 }
 164                         }
 165
 166                         f.DeclaringType.Members.Add(p);
 167
 168                         if (IsObservable)
 169                         {
 170                                 f.DeclaringType.Members.Add(CreateChangedEvent(f));
 171                         }
 172                 }
 173
 174                 static public Boo.Lang.Compiler.Ast.Attribute ConvertExpressionToAttribute(
 175                                                                 Expression item)
 176                 {
 177                         Boo.Lang.Compiler.Ast.Attribute att =
 178                                 new Boo.Lang.Compiler.Ast.Attribute(item.LexicalInfo);
 179                         if (item is MethodInvocationExpression)
 180                         {
 181                                 MethodInvocationExpression m = (MethodInvocationExpression)item;
 182                                 att.Name = m.Target.ToString();
 183                                 att.Arguments = m.Arguments;
 184                                 att.NamedArguments = m.NamedArguments;
 185                         }
 186                         else
 187                         {
 188                                 att.Name = item.ToString();
 189                         }
 190                         return att;
 191                 }
 192
 193                 virtual protected Method CreateGetter(Field f)
 194                 {
 195                         // get:
 196                         //              return <f.Name>
 197                         Method getter = new Method();
 198                         getter.Name = "get";
 199                         getter.Body.Statements.Add(
 200                                 new ReturnStatement(
 201                                         base.LexicalInfo,
 202                                         new ReferenceExpression(f.Name),
 203                                         null)
 204                                 );
 205                         return getter;
 206                 }
 207
 208                 virtual protected Method CreateSetter(Field f)
 209                 {
 210                         Method setter = new Method();
 211                         setter.Name = "set";
 212
 213                         if (null != _setPreCondition)
 214                         {
 215                                 setter.Body.Add(
 216                                         new RaiseStatement(
 217                                                 _setPreCondition.LexicalInfo,
 218                                                 AstUtil.CreateMethodInvocationExpression(
 219                                                         AstUtil.CreateReferenceExpression("System.ArgumentException"),
 220                                                         new StringLiteralExpression("precondition '" +
 221                                                                                                                 _setPreCondition.ToString() +
 222                                                                                                                 "' failed:")),
 223                                                 new StatementModifier(
 224                                                         StatementModifierType.Unless,
 225                                                         _setPreCondition)));
 226                         }
 227                         setter.Body.Add(
 228                                 new BinaryExpression(
 229                                         base.LexicalInfo,
 230                                         BinaryOperatorType.Assign,
 231                                         new MemberReferenceExpression(
 232                                                 CreateRefTarget(f),
 233                                                 f.Name),
 234                                         new ReferenceExpression("value")
 235                                         )
 236                                 );
 237
 238                         if (IsObservable)
 239                         {
 240                                 MethodInvocationExpression mie = new MethodInvocationExpression(
 241                                                                                                                 new ReferenceExpression(ChangedEventName));
 242                                 mie.Arguments.Add(new SelfLiteralExpression());
 243                                 mie.Arguments.Add(
 244                                         new MemberReferenceExpression(
 245                                                 new MemberReferenceExpression(
 246                                                         new ReferenceExpression("System"),
 247                                                         "EventArgs"),
 248                                         "Empty"));
 249                                 setter.Body.Add(mie);
 250                         }
 251                         return setter;
 252                 }
 253
 254                 private Expression CreateRefTarget(Field f)
 255                 {
 256                         if (f.IsStatic) return new ReferenceExpression(LexicalInfo, f.DeclaringType.Name);
 257                         return new SelfLiteralExpression(LexicalInfo);
 258                 }
 259
 260                 protected Event CreateChangedEvent(Field f)
 261                 {
 262                         Event e = new Event(_observable.LexicalInfo);
 263                         e.Name = ChangedEventName;
 264                         e.Type = CodeBuilder.CreateTypeReference(f.LexicalInfo, typeof(System.EventHandler));
 265                         return e;
 266                 }
 267         }
 268 }