Review Request: Add possibility to store Decorators for class- and function declarations

[Sven Brauch]

> On Aug. 27, 2011, 12:19 a.m., Milian Wolff wrote:
> > I have no clue about python: what is a decorator? the @staticmethod ? Then the def foo function definition should be marked static. What is the decorator trying to solve?
> 
> Sven Brauch wrote:
>     Hey,
>     
>     in python, you don't write "static int foo", but "def foo", and then foo = staticmethod(foo). The "staticmethod" function converts the "foo" function into a new one which is static. To simplify this, instead of
>     
>     class my_class():
>       def foo(): pass
>       foo = staticmethod(foo)
>     
>     you can also write
>     
>     class my_class():
>       @staticmethod
>       def foo(): pass
>     
>     Those two are equivalent. You can also define your own decorators, which take functions as arguments and return other functions. There's also a few predefined ones in python.
>     
>     Doesn't PHP also have that "@" syntax? Or is that just in docstrings?
>     
>     Whatever, kdev-python documentation files do something like this:
>     
>     @TypeContainer
>     class list():
>         @appendsType(0)
>         def append(arg0): pass
>     
>     This is the way to let my code know it should track the content type of "list" instances, and other decorators tell it which functions modify that content type.
> 
> Milian Wolff wrote:
>     well the static example doesn't need decorators, you just mark the function as static in the duchain
>     
>     php has no @ syntax, only in docstrings
>     
>     and I still don't get what the @ things in your list example are doing. Anyhow, I doubt this is required for other languages. Imo make it python-only for now until we find another language that has something like that.
>     
>     bye
> 
> Davide Simoncelli wrote:
>     If I'm not wrong Java uses decorators

Okay, so here's another example:

-----
>>> def decorate(obj):
...  obj.some_other_attribute = 42
...  obj.some_attribute = 1337
...  return obj
... 
>>> @decorate
... class my_class(): pass
... 
>>> my_instance = my_class()
>>> my_instance.some_attribute
1337
-----

The class definition construct is again equivalent to writing class my_class(): pass; my_class = decorate(my_class). A more useful example is this:

-----
def debug_return_value(func):
 def wrapper(*args, **kwargs):
  ret = func(*args, **kwargs)
  print ret
  return ret
 return wrapper

@debug_return_value
def my_func(arg):
 return [arg, arg]

my_result = my_func("Hello World!")
-----

The last line will, instead of just writing the return value of my_func into my_result, also print it on the screen, because my_func is replaced by the "wrapper" function by the decorator. Obviously, this is much more flexible than writing print statements all over the function.
I hope it is understandable from this what decorators can be used for.

--

Storing the decorators will be useful, if only for displaying them in the navigation widget.

I'm also okay with making this python-specific, but then I'd need some hints on subclassing data classes with appended lists, while adding more appended lists in the child class. Is this even possible? I didn't manage to do so yet, and I tried quite a few times.


- Sven


-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
http://git.reviewboard.kde.org/r/102432/#review6041
-----------------------------------------------------------


On Aug. 25, 2011, 1:22 p.m., Sven Brauch wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> http://git.reviewboard.kde.org/r/102432/
> -----------------------------------------------------------
> 
> (Updated Aug. 25, 2011, 1:22 p.m.)
> 
> 
> Review request for KDevelop.
> 
> 
> Summary
> -------
> 
> This adds a list of Decorators to each class and function declaration, and a Decorator class which stores information about those decorators.
> This is currently relevant for the python language, which has a pattern like this:
> 
> class c():
>     @staticmethod
>     def foo():
>         pass
> 
> I didn't have an internet connection for research available, but I think other languages might have similar patterns, so this can go into kdevplatform.
> Also, even after several hours of experimentation I couldn't figure out how to inherit from a class which defines appended lists, adding another one... some documentation on that would be appreciated :)
> 
> 
> Diffs
> -----
> 
>   language/CMakeLists.txt 4399ebb 
>   language/duchain/classdeclaration.h 409a3a4 
>   language/duchain/classdeclaration.cpp 0670209 
>   language/duchain/decorator.h PRE-CREATION 
>   language/duchain/functiondeclaration.h 7f084a9 
>   language/duchain/functiondeclaration.cpp fb442dc 
> 
> Diff: http://git.reviewboard.kde.org/r/102432/diff
> 
> 
> Testing
> -------
> 
> 
> Thanks,
> 
> Sven
> 
>

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.kde.org/pipermail/kdevelop-devel/attachments/20110901/5df17e7a/attachment.html>