循序渐进学Boo 高级篇

经过前面两篇文章的介绍，相信大家对Boo的一些基本特性有所了解，本文着重介绍Boo深层次的知识以及其在AOP中的实现。

在开始之前先给大家做些准备：

一、Boo Parser

目前Boo的编译器使用C#实现，用ANTLR进行解析。
Compiler Steps 

Pipelines consist of a set of steps that the compiler passes the code through. The source code for all the steps is here.

The order of steps when you compile a script is like this:

1.First the Boo Parser (and lexer): Boo.Lang.Parser.BooParsingStep.
    1.The rules the Boo parser uses are defined in this ANTLR grammar file
    2.The boo lexer turns the text script into a set of tokens, and the boo parser converts the tokens into an abstract syntax tree (AST). I'll show examples of this later on. Each step after the parser is basically just working on this AST and transforming it. At the end, the AST is used to produce raw .NET assembly code (IL). The steps that happen after the parser step:
2.InitializeTypeSystemServices
3.PreErrorChecking
4.InitializeNameResolutionService
5.IntroduceGlobalNamespaces
6.TransformCallableDefinitions
7.BindTypeDefinitions
8.[BindNamespaces]
9.BindBaseTypes
10.BindAndApplyAttributes
11.ExpandMacros
12.IntroduceModuleClasses
13.NormalizeStatementModifiers
14.[NormalizeTypeAndMemberDefinitions]
15.BindTypeDefinitions
16.BindBaseTypes
17.ResolveTypeReferences
18.BindTypeMembers
19.[ProcessInheritedAbstractMembers]
20.ProcessMethodBodiesWithDuckTyping
21.[ProcessAssignmentsToValueTypeMembers]
22.[ExpandProperties]
23.[StricterErrorChecking]
24.[RemoveDeadCode]
25.NormalizeIterationStatements
26.ProcessSharedLocals
27.ProcessClosures
28.ProcessGenerators
29.InjectCallableConversions
30.[ImplementICallableOnCallableDefinitions]
31.[EmitAssembly]
32.and finally [SaveAssembly] or [RunAssembly] 

二、Boo.Lang.Compiler.AbstractAstAttribute与Boo.Lang.Compiler.AbstractAstMacro

继承体系如下：

 

public abstract class Node : ICloneable
{
    // Fields
    protected Node _parent;
    ......
    // Mothods
    public abstract void Accept(IAstVisitor visitor);
    public abstract object Clone();
    public Node CloneNode(); 

    public TAncestor GetAncestor<TAncestor>() where TAncestor: Node;
    public Node GetAncestor(NodeType ancestorType);
    public Node GetAncestor(NodeType ancestorType, int limitDepth);
    public IEnumerable<TAncestor> GetAncestors<TAncestor>() where TAncestor: Node; 

    public virtual bool Replace(Node existing, Node newNode);
    public int ReplaceNodes(Node pattern, Node template);
    public int ReplaceNodes(NodePredicate predicate, Node template);
    public string ToCodeString();
    public override string ToString();
    ......
    // Properties
    public abstract NodeType NodeType {get;}
    public Node ParentNode {get;}
    ......
} 

在前一篇文章我们看到：

class AssignFieldsMacro(AbstractAstMacro): 
    override def Expand(macro as MacroStatement):  
#        ctor = (macro.ParentNode.ParentNode as Constructor) 
        ctor = macro.GetAncestor(NodeType.Constructor) as Constructor
        b = Block()
        
        for param in ctor.Parameters: 
            assign = BinaryExpression(BinaryOperatorType.Assign,
                            ReferenceExpression("_" + param.Name),
                            ReferenceExpression(param.Name))
            b.Add(assign)
        
        return b

class Customer:
    [property(Name)]
    private _name as string

    def constructor(name as string):
        AssignFields
        #autoAssign

上述Macro会在编译阶段将Customer构造函数的代码扩展为：

def constructor(name as string):
    self._name = name

[注]：

目前在Boo 0.91下可以有更简洁的写法：

macro autoAssign: 
    ctor = autoAssign.GetAncestor(NodeType.Constructor) as Constructor
    b = Block()
    
    for param in ctor.Parameters: 
        assign = BinaryExpression(BinaryOperatorType.Assign,
                        ReferenceExpression("_" + param.Name),
                        ReferenceExpression(param.Name))
        b.Add(assign)
    
    return b

三、DepthFirstVisitor与DepthFirstTransformer

它们都继承于IAstVisitor。

1、DepthFirstVisitor访问AST中的所有节点，但是不会对AST进行修改操作。请看下面这个例子：

class CaptureReferences(DepthFirstVisitor):
    [getter(Found)]
    _found = []
    
    def constructor(node as Node):
        node.Accept(self)
    override def OnReferenceExpression(reference as ReferenceExpression):
        _found.Add(reference)

上例就是通过DepthFirstVisitor提供的OnReferenceExpression方法获取所用到的ReferenceExpression，具体使用如下：

expression = BinaryExpression( 
                    BinaryOperatorType.Division, 
                    BinaryExpression( 
                        BinaryOperatorType.Subtraction, 
                        ReferenceExpression("x"), 
                        IntegerLiteralExpression(3)), 
                    ReferenceExpression("t")) 
print expression.ToCodeString()    // (x-3)/t

references = CaptureReferences(expression).Found
print join(references)        // x t

2、DepthFirstTransformer访问AST中的所有节点，并可以对AST进行添加与删除操作。通常在自定义的Macro与Attribute中,会需要对当前的AST进行修改以根据要求产生相应的AST，这时就会用到DepthFirstTransformer提供的RemoveCurrentNode,ReplaceCurrentNode等方法。请看下面这个例子：

class WithMacro(AbstractAstMacro):

    private class NameExpander(DepthFirstTransformer):

        _inst as ReferenceExpression

        def constructor(inst as ReferenceExpression):
            _inst = inst

        override def OnReferenceExpression(node as ReferenceExpression):
            // if the name of the reference begins with '_'
            // then convert the reference to a member reference
            // of the provided instance
            if node.Name.StartsWith('_'):
                // create the new member reference and set it up
                mre = MemberReferenceExpression(node.LexicalInfo)
                mre.Name = node.Name[1:]
                mre.Target = _inst.CloneNode()

                // replace the original reference in the AST
                // with the new member-reference
                ReplaceCurrentNode(mre)

    override def Expand(macro as MacroStatement) as Statement:
        assert 1 == macro.Arguments.Count
        assert macro.Arguments[0] isa ReferenceExpression

        inst = macro.Arguments[0] as ReferenceExpression

        // convert all _<ref> to inst.<ref>
        block = macro.Body
        ne = NameExpander(inst)
        ne.Visit(block)
        return block

class Example:
    public Name as string
    public Content as string
    
    def DoSomething([default('hello')]cstr as string):
        print cstr.ToUpper()

ex = Example()
with ex:
    _Name = "hans"
    _Content = "test"
    _DoSomething('hello world')
print ex.Name,ex.Content

[注]：

目前在Boo 0.91下可以有更简洁的写法：

macro with(target, body as Expression*):
    for expression in body:
        match expression:
            case BinaryExpression(Left: mre = MemberReferenceExpression(Target: OmittedExpression())):
                mre.Target = target
            case MethodInvocationExpression(Target: mre = MemberReferenceExpression(Target: OmittedExpression())):
                 mre.Target = target
    yield

with ex:
    .Name = "hans"
    .Content = "test"
    .DoSomething('hello world')

可以看到上述的with使用方法更为大家所熟悉。

四、Boo与AOP

为了建立松散耦合的、可扩展的企业系统，AOP应用到的横切技术，通常分为动态横切和静态横切两种类型。

静态横切和动态横切的区别在于它不修改一个给定对象的执行行为。相反，它允许通过引入附加的方法字段和属性来修改对象的结构。
此外，静态横切可以把扩展和实现附加到对象的基本结构中。

通过前面的介绍，我们知道了Boo有着强大的编译器扩展功能，可以通过AbstractAstAttribute与AbstractAstMacro很容易进行AOP的静态横切。

1、<在.Net中关于AOP的实现>中的”设计一个计算器，它能提供加法和减法功能。”例子可以简单通过如下的Boo代码实现：

[AttributeUsage(AttributeTargets.Method)]
class LogAttribute(AbstractAstAttribute):
    def constructor():
        pass
       
    override def Apply(node as Node):
        method as Method = node
        // Before
        expression = cast(ReturnStatement, method.Body.Statements[-1]).Expression
        match expression:
            case [| $left+$right |]:
                code = [| print "${$(method.Name)}(${$left},${$right})" |]
            case [| $left-$right |]:
                code = [| print "${$(method.Name)}(${$left},${$right})" |]
            otherwise:
                code = [| print "${$(method.Name)}" |]        
        // Body
        tmp = AstUtil.CreateReferenceExpression("__${method.Name}__")
        tbody = [|
            block:
                $tmp = $expression
                // After
                print "Result is ${$tmp}"
                print "After ${$(method.Name)} at ${date.Now}"
                return $tmp
        |].Body
        method.Replace(method.Body,tbody)
        method.Body.Insert(0, code)        

class Calculator:
"""
Description of Calculator
核心关注点是加法和减法,而通用业务-横切关注点则是日志功能.
"""
    def constructor():
        pass
    [log]
    def Add(x as int, y as int):
        return x+y
    [log]
    def Substract(x as int, y as int):
        return x-y

calc = Calculator()
calc.Add(2,10)

2、<在.Net中关于AOP的实现（补遗）>中“一个已经实现了收发邮件的类Mail。然而它并没有实现地址验证的功能。”例子，利用Boo可以将IValidatable接口织入到原有的Mail类中，这是一种非常形象的introduce功能：

[AttributeUsage(AttributeTargets.Class)]
class ValidatableAttribute(AbstractAstAttribute):
    def constructor():
        pass
       
    override def Apply(node as Node):
        classDef as ClassDefinition = node
        classDef.BaseTypes.Add(SimpleTypeReference("Examples.IValidatable"))
        AddMethod(classDef)
        
    def AddMethod(classDef as ClassDefinition):
        validator = Method()
#        fields = FindField(classDef)
#        field as Field = fields[0]
        validator.Name = "ValidateAddress"
        code = [|
            if string.IsNullOrEmpty($(ReferenceExpression('_mail'))):
                return false
            return true
        |]
        validator.Body.Add(code)
        classDef.Members.Add(validator)

[validatable]
class Mail:
"""Description of Mail"""
    [property(Email)]
    _mail as string
    
    def constructor():
        pass
    def constructor(mail as string):
        _mail = mail
        
    def Send():
        pass
    def Receive():
        pass

interface IValidatable:
    def ValidateAddress() as bool:
        pass

mail = Mail("test@gmail.com")
print mail.Email
mail.ValidateAddress()

当然，上面的两个例子还相当不完善，只是向大家展示了Boo在AOP方面的优势，更好的实现需要大家自己去学习了解。

参考：

http://boo.codehaus.org/Type+System
http://boo.codehaus.org/Compiler+Steps
http://tore.vestues.no/2008/12/27/the-boo-extensibility-tutorials/

http://www.ibm.com/developerworks/cn/java/j-aopsc/
http://www.cnblogs.com/wayfarer/articles/233212.html