[
https://issues.apache.org/jira/browse/THRIFT-897?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12908172#action_12908172
]
Jeff DeCew edited comment on THRIFT-897 at 9/10/10 4:24 PM:
------------------------------------------------------------
What would be the cost of doing type resolution? I think this might be the
most convenient (and backward-compatible) behavior, but I have no idea if it is
feasible in the current architecture of the compiler.
This is my proposal:
{code}
enum MyEnum {
A = 1
X = 2
}
enum OtherEnum {
B = 1
X = 2
}
// Automatically resolve A to MyEnum.A and allow to compile
const MyEnum myConst1 = A;
// Automatically resolve B to MyEnum.B and FAIL to compile because MyEnum.B
does not exist
const MyEnum myConst2 = B;
// Allow to compile
const MyEnum myConst3 = OtherEnum.B;
// Allow to compile
const MyEnum myConst4 = MyEnum.A;
// Automatically resolve X to MyEnum.X and allow to compile (but maybe warn
that X was ambiguously resolved)
const MyEnum myConst5 = X;
// Can't automatically resolve A (even though it is unique), FAIL to compile
const i32 myConst6 = A;
{code}
was (Author: jdecew):
What would be the cost of doing type resolution? I think this might be the
most convenient (and backward-compatible) behavior, but I have no idea if it is
feasible in the current architecture of the compiler.
This is my proposal:
{code}
enum MyEnum {
A = 1
X = 2
}
enum OtherEnum {
B = 1
X = 2
}
// Automatically resolve A to MyEnum.A and allow to compile
const MyEnum myConst1 = A;
// Automatically resolve B to MyEnum.B and FAIL to compile because MyEnum.B
does not exist
const MyEnum myConst2 = B;
// Allow to compile
const MyEnum myConst3 = OtherEnum.B;
// Allow to compile
const MyEnum myConst4 = MyEnum.A;
// Automatically resolve X to MyEnum.X and allow to compile (but maybe warn
that X was ambiguously resolved)
const MyEnum myConst5 = X;
{code}
> Don't allow unqualified constant access to enum values
> ------------------------------------------------------
>
> Key: THRIFT-897
> URL: https://issues.apache.org/jira/browse/THRIFT-897
> Project: Thrift
> Issue Type: Bug
> Components: Compiler (General)
> Affects Versions: 0.1, 0.2, 0.3, 0.4
> Reporter: Bryan Duxbury
> Fix For: 0.5
>
>
> Through looking at THRIFT-544 and THRIFT-895, it's come to my attention that
> we currently register each of every enum's values as a global (and scoped)
> constant. This allows you to do things like:
> {code}
> enum MyEnum {
> A = 1
> B = 2
> }
> const MyEnum myEnumVar = A;
> {code}
> This is handy, insofar as you might want to use the values of an enum in
> constant or default circumstances. However, this behavior is unstable - if
> you have two enums with values that have the same name, all constant
> references will point at the last occurrence of the name. Further, in order
> to allow this to go on, we must not check if any constant has been declared
> twice, which means you can get stupid, detectable errors in your IDL very
> easily.
> I propose that we stop allowing this method of access, and instead require
> the enum values referenced in constant context to be prefixed with the enum
> type's name. For instance:
> {code}
> enum MyEnum {
> A = 1
> B = 2
> }
> const MyEnum myEnumVar = MyEnum.A;
> {code}
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
