Uploaded image for project: 'Scala Programming Language'
  1. Scala Programming Language
  2. SI-6240

thread safety of reflection API

          Details

            Description

            It's sort of implemented, but was never tested. Also trees aren't synchronized at all, because it was only recently when they've been converted to abstract types.

            NOTE that this issue mostly affects runtime reflection, not reflection used in macros. Compiler itself has never been thread-safe, so noone uses it from multiple threads, therefore issues might only arise if a macro spawns multiple threads, which do certain operations simultaneously.

              Attachments

                Issue Links

                is duplicated by

                Bug - A problem which impairs or prevents the functions of the product. SI-8929 Typetag and concurrency issues

                • Major - Major loss of function.
                • CLOSED
                relates to

                Bug - A problem which impairs or prevents the functions of the product. SI-8131 residual race condition in runtime reflection

                • Blocker - Blocks development and/or testing work, production could not run.
                • CLOSED

                  Activity

                  Ascending order - Click to sort in descending order
                  49 older comments
                  Hide
                  Permalink
                  ngocdaothanh Ngoc Dao added a comment -

                  In Scala 2.11, you can use "typeOf".
                  In Scala 2.10, use "manifest" instead of "typeOf".

                  Example:

                  Show
                  ngocdaothanh Ngoc Dao added a comment - In Scala 2.11, you can use "typeOf". In Scala 2.10, use "manifest" instead of "typeOf". Example: Code for Scala 2.11: https://github.com/xitrum-framework/xitrum/blob/master/src/main/scala-2.11/xitrum/scope/request/ParamAccess.scala Equivalent code for Scala 2.10: https://github.com/xitrum-framework/xitrum/blob/master/src/main/scala-2.10/xitrum/scope/request/ParamAccess.scala
                  Hide
                  Permalink
                  malcolmgreaves Malcolm Greaves added a comment -

                  Will this glaring problem never get fixed on 2.10? The problem with Manifests is that they cannot account for type variance.

                  Show
                  malcolmgreaves Malcolm Greaves added a comment - Will this glaring problem never get fixed on 2.10? The problem with Manifests is that they cannot account for type variance.
                  Hide
                  Permalink
                  retronym Jason Zaugg added a comment -

                  Sorry, we don't have the resources to backport this.

                  2.10.x is now in maintainence mode and we are only targetting critical fixes. Given that reflection is an experimental module, and that the patch to add thread safety was pretty invasive and difficult to merge, we can't take that on.

                  Show
                  retronym Jason Zaugg added a comment - Sorry, we don't have the resources to backport this. 2.10.x is now in maintainence mode and we are only targetting critical fixes. Given that reflection is an experimental module, and that the patch to add thread safety was pretty invasive and difficult to merge, we can't take that on.
                  Hide
                  Permalink
                  malcolmgreaves Malcolm Greaves added a comment - - edited

                  Ah...I understand. Sometimes reality is harsh. FWIW I think that Scala is a superb language. I really enjoy using it. It's a shame that the JVM doesn't have reified generics and causes all these kinds of problems.

                  Show
                  malcolmgreaves Malcolm Greaves added a comment - - edited Ah...I understand. Sometimes reality is harsh. FWIW I think that Scala is a superb language. I really enjoy using it. It's a shame that the JVM doesn't have reified generics and causes all these kinds of problems.
                  Hide
                  Permalink
                  retronym Jason Zaugg added a comment -

                  Erasure isn't to blame here, in fact it is rather crucial for a language like Scala to be able to innovate in its type system. Compare this to F#, for example, which hasn't been able to add type constructor polymorphism due to the assumptions about generics built into the VM.

                  Show
                  retronym Jason Zaugg added a comment - Erasure isn't to blame here, in fact it is rather crucial for a language like Scala to be able to innovate in its type system. Compare this to F#, for example, which hasn't been able to add type constructor polymorphism due to the assumptions about generics built into the VM.

                    People

                    • Assignee:
                      burmako Eugene Burmako
                      Reporter:
                      burmako Eugene Burmako
                    • Votes:
                      28 Vote for this issue
                      Watchers:
                      52 Start watching this issue

                      Dates

                      • Created:
                        Updated:
                        Resolved: