#1000958
- Created on2012-03-30 19:53
- Reported by
- StatusFixed
- PriorityNormal (3)
- Assigned to
- Milestone
- Plan Level-
- Due Date-
structured type, incorrect semantic var highlighting
Look at the attached self-explaining scala-ide-01.png image - it is for current nightly.
Leave a comment
on 2012-03-30 21:36 *
By Mirco Dotta
Assigned to set to Mirco Dotta
Component changed from None to Semantic Highlight
Thanks a lot for reporting it. I'll have a look at it next week!
(In revision:0e477495713d89114c9541170f446d22a3f2bcfe) Corrected classification of ``var``s.
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: feature/tuning-semantic-highlighting
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: feature/tuning-semantic-highlighting
on 2012-04-04 16:02 *
By Mirco Dotta
(In revision:186a9363236302f233420e9831ae8a16981df29d) Corrected classification of ``var``s.
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: feature/tuning-semantic-highlighting
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: feature/tuning-semantic-highlighting
on 2012-04-04 16:06 *
By Mirco Dotta
(In revision:946e26c6934fb3e44b6a46dea2e40e9395892033) Corrected classification of ``var``s.
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: feature/tuning-semantic-highlighting
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: feature/tuning-semantic-highlighting
on 2012-04-11 22:29 *
By Mirco Dotta
(In revision:0fe77ed3ea0ebd2fe94b74a9c87e54b09106e148) Corrected classification of ``var``s.
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: feature/tuning-semantic-highlighting
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: feature/tuning-semantic-highlighting
on 2012-04-11 22:31 *
By Mirco Dotta
(In revision:0fe77ed3ea0ebd2fe94b74a9c87e54b09106e148) Corrected classification of ``var``s.
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: master
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: master
on 2012-04-15 10:46 *
By Mirco Dotta
(In revision:0fe77ed3ea0ebd2fe94b74a9c87e54b09106e148) Corrected classification of ``var``s.
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: platform/juno
A ``var`` that gets accessed through its getter (remember, a ``var`` gets
always compiled into a getter and a setter by ``scalac`` - uniform access
principle) must be classified as a variable (either TemplateVar or LocalVar).
The difficulty is that when a ``var`` gets accessed through its getter, the
symbol handle we have in the ``Tree`` is a ``MethodSymbol`` for the getter.
Therefore, to decide if behind a getter sits a ``val`` or a ``var`` we need to
check if the symbol's owner (i.e., the getter's owner) contains a setter method
that matches the getters' name (this can be done using the compiler method
``nme.getterToSetter``).
Fixed #1000958.
Branch: platform/juno