#479, sub-directives via keywords

Cython/Compiler/Options.py

@@ -65,6 +65,9 @@ directive_defaults = {
     'infer_types': False,
     'autotestdict': True,
     
+    'warn': None,
+    'warn.undeclared': False,
+
 # test support
     'test_assert_path_exists' : [],
     'test_fail_if_path_exists' : [],

Cython/Compiler/ParseTreeTransforms.py

@@ -427,55 +427,74 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations):
             node.cython_attribute = self.directive_names.get(node.name)
         return node
 
-    def try_to_parse_directive(self, node):
+    def try_to_parse_directives(self, node):
         # If node is the contents of an directive (in a with statement or
-        # decorator), returns (directivename, value).
+        # decorator), returns a list of (directivename, value) pairs.
         # Otherwise, returns None
-        optname = None
         if isinstance(node, CallNode):
             self.visit(node.function)
             optname = node.function.as_cython_attribute()
-
             if optname:
                 directivetype = Options.directive_types.get(optname)
                 if directivetype:
                     args, kwds = node.explicit_args_kwds()
+                    directives = []
+                    key_value_pairs = []
+                    if kwds is not None and directivetype is not dict:
+                        for keyvalue in kwds.key_value_pairs:
+                            key, value = keyvalue
+                            sub_optname = "%s.%s" % (optname, key.value)
+                            if Options.directive_types.get(sub_optname):
+                                directives.append(self.try_to_parse_directive(sub_optname, [value], None, keyvalue.pos))
+                            else:
+                                key_value_pairs.append(keyvalue)
+                        if not key_value_pairs:
+                            kwds = None
+                        else:
+                            kwds.key_value_pairs = key_value_pairs
+                        if directives and not kwds and not args:
+                            return directives
+                    directives.append(self.try_to_parse_directive(optname, args, kwds, node.function.pos))
+                    return directives
+                
+        return None
+
+    def try_to_parse_directive(self, optname, args, kwds, pos):
+        directivetype = Options.directive_types.get(optname)
         if optname == 'infer_types':
             if kwds is not None or len(args) != 1:
-                        raise PostParseError(node.function.pos,
+                raise PostParseError(pos,
                     'The %s directive takes one compile-time boolean argument' % optname)
             elif isinstance(args[0], BoolNode):
                 return (optname, args[0].value)
             elif isinstance(args[0], NoneNode):
                 return (optname, None)
             else:
-                        raise PostParseError(node.function.pos,
+                raise PostParseError(pos,
                     'The %s directive takes one compile-time boolean argument' % optname)
         elif directivetype is bool:
             if kwds is not None or len(args) != 1 or not isinstance(args[0], BoolNode):
-                        raise PostParseError(node.function.pos,
+                raise PostParseError(pos,
                     'The %s directive takes one compile-time boolean argument' % optname)
             return (optname, args[0].value)
         elif directivetype is str:
             if kwds is not None or len(args) != 1 or not isinstance(args[0], (StringNode, UnicodeNode)):
-                        raise PostParseError(node.function.pos,
+                raise PostParseError(pos,
                     'The %s directive takes one compile-time string argument' % optname)
             return (optname, str(args[0].value))
         elif directivetype is dict:
             if len(args) != 0:
-                        raise PostParseError(node.function.pos,
+                raise PostParseError(pos,
                     'The %s directive takes no prepositional arguments' % optname)
             return optname, dict([(key.value, value) for key, value in kwds.key_value_pairs])
         elif directivetype is list:
             if kwds and len(kwds) != 0:
-                        raise PostParseError(node.function.pos,
+                raise PostParseError(pos,
                     'The %s directive takes no keyword arguments' % optname)
             return optname, [ str(arg.value) for arg in args ]
         else:
             assert False
 
-        return None
-
     def visit_with_directives(self, body, directives):
         olddirectives = self.directives
         newdirectives = copy.copy(olddirectives)
@@ -495,9 +514,9 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations):
             # Split the decorators into two lists -- real decorators and directives
             realdecs = []
             for dec in node.decorators:
-                directive = self.try_to_parse_directive(dec.decorator)
-                if directive is not None:
-                    directives.append(directive)
+                new_directives = self.try_to_parse_directives(dec.decorator)
+                if new_directives is not None:
+                    directives.extend(new_directives)
                 else:
                     realdecs.append(dec)
             if realdecs and isinstance(node, CFuncDefNode):
@@ -533,18 +552,18 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations):
     def visit_CVarDefNode(self, node):
         if node.decorators:
             for dec in node.decorators:
-                directive = self.try_to_parse_directive(dec.decorator)
+                for directive in self.try_to_parse_directives(dec.decorator) or []:
                     if directive is not None and directive[0] == u'locals':
                         node.directive_locals = directive[1]
                     else:
                         self.context.nonfatal_error(PostParseError(dec.pos,
                             "Cdef functions can only take cython.locals() decorator."))
-                    continue
         return node
                                    
     # Handle with statements
     def visit_WithStatNode(self, node):
-        directive = self.try_to_parse_directive(node.manager)
+        directive_dict = {}
+        for directive in self.try_to_parse_directives(node.manager) or []:
             if directive is not None:
                 if node.target is not None:
                     self.context.nonfatal_error(
@@ -552,7 +571,9 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations):
                 else:
                     name, value = directive
                     if self.check_directive_scope(node.pos, name, 'with statement'):
-                    return self.visit_with_directives(node.body, {name:value})
+                        directive_dict[name] = value
+        if directive_dict:
+            return self.visit_with_directives(node.body, directive_dict)
         return self.visit_Node(node)
 
 class WithTransform(CythonTransform, SkipDeclarations):

Cython/Compiler/Parsing.py

@@ -2579,7 +2579,7 @@ def p_code(s, level=None):
             repr(s.sy), repr(s.systring)))
     return body
 
-COMPILER_DIRECTIVE_COMMENT_RE = re.compile(r"^#\s*cython:\s*(\w+\s*=.*)$")
+COMPILER_DIRECTIVE_COMMENT_RE = re.compile(r"^#\s*cython:\s*((\w|[.])+\s*=.*)$")
 
 def p_compiler_directive_comments(s):
     result = {}

tests/compile/c_directives.pyx

 # cython: boundscheck  =  False
 # cython: ignoreme = OK
+# cython: warn.undeclared = False
 
 # This testcase is most useful if you inspect the generated C file
 
@@ -32,3 +33,8 @@ def i(object[int] buf):
     with bc(True):
         print buf[3] # bs
     
+from cython cimport warn as my_warn
+
+@my_warn(undeclared=True)
+def j():
+    pass