Adds real support for synchronized modifier and statement.

Troy Melhase · Troy Melhase · commit 431b568c8a30 · 2012-02-04T19:51:26.000-05:00
diff --git a/doc/features.md b/doc/features.md
@@ -118,7 +118,15 @@ Java `switch` and `case` statements are translated to equivalent Python `if` sta
 
 ##### synchronized
 
-The compiler currently discards the `synchronized` Java statement.  This is incorrect behavior.  The correct behavior is (and will be) to apply a synchronized decorator to a function wrapping the construct.
+In the case of a `synchronized` method or static method, the compiler will include a decorator, `@synchronized` in
+the method or static method preamble.  In the case of a `synchronized` block, the compiler will translate to this form:
+
+    with lock_for_object(expr):
+        ...
+
+The `lock_for_object` callable is the default and can be controlled via the `methodLockFunctionName` config item.
+Also of note, the default `modulePrologueHandlers` uses a generator named `maybeSyncHelpers` to include
+Python helper code for synchronization.
 
 ##### return
 Java `return` statements are translated to equivalent Python `return` statements.
diff --git a/java2python/compiler/visitor.py b/java2python/compiler/visitor.py
@@ -511,6 +511,19 @@ def acceptSwitch(self, node, memo):
                     self.factory.expr(left='pass', parent=caseContent)
         self.children.remove(parExpr)
 
+    def acceptSynchronized(self, node, memo):
+        """ Accept and process a synchronized statement (not a modifier). """
+        module = self.parents(lambda x:x.isModule).next()
+        module.needsSyncHelpers = True
+        if node.parent.type == tokens.MODIFIER_LIST:
+            # Skip any synchronized modifier
+            return
+        lockName = self.configHandler('LockFunction', 'Name', 'lock_for_object')
+        withFs = '{left} %s({right}):' % lockName
+        sync = self.factory.statement('with', fs=withFs, parent=self)
+        sync.expr.walk(node.children[0], memo)
+        sync.walk(node.children[1], memo)
+
     def acceptThrow(self, node, memo):
         """ Accept and process a throw statement. """
         throw = self.factory.statement('raise', fs=FS.lsr, parent=self)
diff --git a/java2python/config/default.py b/java2python/config/default.py
@@ -25,6 +25,7 @@
     basic.shebangLine,
     basic.simpleDocString,
     basic.maybeBsr,
+    basic.maybeSyncHelpers,
 ]
 
 
@@ -51,6 +52,10 @@
     basic.defaultParams,
 ]
 
+# This is the name of the callable used to construct locks for an object with
+# the synchronized keyword.
+methodLockFunctionName = 'lock_for_object'
+
 classBaseHandlers = [
     basic.defaultBases,
 ]
@@ -91,6 +96,8 @@
 methodPrologueHandlers = [
     basic.maybeAbstractMethod,
     basic.maybeClassMethod,
+    # NB:  synchronized should come after classmethod
+    basic.maybeSynchronizedMethod,
     basic.overloadedClassMethods,
 ]
 
diff --git a/java2python/mod/basic.py b/java2python/mod/basic.py
@@ -123,27 +123,47 @@ def maybeClassMethod(method):
     if method.isStatic and 'classmethod' not in method.decorators:
         yield '@classmethod'
 
+
 def maybeAbstractMethod(method):
     if method.parent and method.parent.isInterface:
         yield '@abstractmethod'
 
 
+def maybeSynchronizedMethod(method):
+    if 'synchronized' in method.modifiers:
+        module = method.parents(lambda x:x.isModule).next()
+        module.needsSyncHelpers = True
+        yield '@synchronized'
+
+
 def globalNameCounter(original, counter=count()):
     return '__{0}_{1}'.format(original, counter.next())
 
 
 def getBsrSrc():
     from inspect import getsource
-    from java2python.mod.includes import bsr
+    from java2python.mod.include.bsr import bsr
     return getsource(bsr)
 
 
+def getSyncHelpersSrc():
+    from inspect import getsource
+    from java2python.mod.include import sync
+    return getsource(sync)
+
+
 def maybeBsr(module):
     if getattr(module, 'needsBsrFunc', False):
         for line in getBsrSrc().split('\n'):
             yield line
 
 
+def maybeSyncHelpers(module):
+    if getattr(module, 'needsSyncHelpers', False):
+        for line in getSyncHelpersSrc().split('\n'):
+            yield line
+
+
 def classContentSort(obj):
     isMethod = lambda x:x and x.isMethod
 
diff --git a/java2python/mod/include/__init__.py b/java2python/mod/include/__init__.py
diff --git a/java2python/mod/include/bsr.py b/java2python/mod/include/bsr.py
diff --git a/java2python/mod/include/sync.py b/java2python/mod/include/sync.py
@@ -0,0 +1,12 @@
+from threading import RLock
+
+_locks = {}
+def lock_for_object(obj, locks=_locks):
+    return locks.setdefault(id(obj), RLock())
+
+
+def synchronized(call):
+    def inner(*args, **kwds):
+        with lock_for_object(call):
+            return call(*args, **kwds)
+    return inner
diff --git a/java2python/mod/include/sync_test.py b/java2python/mod/include/sync_test.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+
+from threading import RLock
+
+_locks = {}
+def lock_for_object(obj, locks=_locks):
+    return locks.setdefault(id(obj), RLock())
+
+def synchronized(call):
+    def inner(*args, **kwds):
+        with lock_for_object(call):
+            return call(*args, **kwds)
+    return inner
+
+class Main(object):
+
+    def __init__(self):
+        self.attr = object()
+
+    def b1(self):
+        r = []
+        with lock_for_object(self.attr):
+            r.append(0)
+        return r
+
+    def b2(self):
+        r = []
+        with lock_for_object(self.attr):
+            r.append(0)
+        return r
+
+    def m1(self):
+        return id(lock_for_object(self))
+
+    def m2(self):
+        return id(lock_for_object(self))
+
+    @classmethod
+    def c1(cls):
+        return id(lock_for_object(cls))
+
+    @classmethod
+    def c2(cls):
+        return id(lock_for_object(cls))
+
+    @synchronized
+    def s1(self, *values, **kwargs):
+        return [values, kwargs]
+
+    @synchronized
+    def s2(self, *values, **kwargs):
+        return [values, kwargs]
+
+    @classmethod
+    @synchronized
+    def cs1(cls, *values, **kwargs):
+        return [cls, values, kwargs]
+
+    @classmethod
+    @synchronized
+    def cs2(cls, *values, **kwargs):
+        return [cls, values, kwargs]
+
+
+
+if __name__ == '__main__':
+    x = Main()
+    expected_count = 0
+
+    assert x.b1() == x.b2()
+    expected_count += 1 # one for the attr, used twice
+
+    assert x.c1() == x.c2()
+    expected_count += 1 # one for the class, used twice
+
+    assert x.m1() == x.m2()
+    expected_count += 1 # one for the instance, used twice
+
+    assert x.s1() == x.s2()
+    expected_count += 2 # one for each instance method
+
+    assert x.cs1() == x.cs2()
+    expected_count += 2 # one for each class method
+
+    assert expected_count == len(_locks)
+
+    print '[PASS]'
+
diff --git a/test/Synchronized1.java b/test/Synchronized1.java
@@ -0,0 +1,17 @@
+class Synchronized1 {
+
+    public synchronized void run() {
+	System.out.println(0);
+    }
+
+    public static synchronized void class_run() {
+	System.out.println(0);
+    }
+
+    public static void main(String[] args) {
+        Synchronized1 obj = new Synchronized1();
+        obj.run();
+        obj.class_run();
+
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@`
`25`	`25`	`basic.shebangLine,`
`26`	`26`	`basic.simpleDocString,`
`27`	`27`	`basic.maybeBsr,`
	`28`	`+ basic.maybeSyncHelpers,`
`28`	`29`	`]`
`29`	`30`
`30`	`31`
`@@ -51,6 +52,10 @@`
`51`	`52`	`basic.defaultParams,`
`52`	`53`	`]`
`53`	`54`
	`55`	`+# This is the name of the callable used to construct locks for an object with`
	`56`	`+# the synchronized keyword.`
	`57`	`+methodLockFunctionName = 'lock_for_object'`
	`58`	`+`
`54`	`59`	`classBaseHandlers = [`
`55`	`60`	`basic.defaultBases,`
`56`	`61`	`]`
`@@ -91,6 +96,8 @@`
`91`	`96`	`methodPrologueHandlers = [`
`92`	`97`	`basic.maybeAbstractMethod,`
`93`	`98`	`basic.maybeClassMethod,`
	`99`	`+ # NB: synchronized should come after classmethod`
	`100`	`+ basic.maybeSynchronizedMethod,`
`94`	`101`	`basic.overloadedClassMethods,`
`95`	`102`	`]`
`96`	`103`