Put members of enum class into separate scope

Author: tim-dlang

src/cppconv/cppdeclaration.d

@@ -344,6 +344,7 @@ enum DeclarationFlags
     constExpr = 0x2000,
     templateSpecialization = 0x4000,
     templateParam = 0x8000,
+    enumClass = 0x10000,
 }
 
 struct DeclarationKey

src/cppconv/cppsemantic.d

@@ -873,6 +873,15 @@ void analyzeClassSpecifier(Tree tree, ref IteratePPVersions ppVersion,
             iteratePPVersions!analyzeClassSpecifier(c, ppVersion, semantic, info);
         }
     }
+    else if (tree.nonterminalID == ParserWrapper.nonterminalIDFor!"EnumKey")
+    {
+        assert(info.key.length == 0, text(info.key, " ", tree.childs[0].name));
+        assert(tree.childs.length >= 1);
+        assert(tree.childs[0].nodeType == NodeType.token);
+        info.key = tree.childs[0].content;
+        if (tree.childs.length >= 2)
+            info.key ~= " " ~ tree.childs[1].content;
+    }
     else if (tree.nonterminalID == ParserWrapper.nonterminalIDFor!"ClassKey")
     {
         assert(info.key.length == 0, text(info.key, " ", tree.childs[0].name));

src/cppconv/cppsemantic1.d

@@ -831,6 +831,8 @@ void runSemantic(ref SemanticRunInfo semantic, ref Tree tree, Tree parent,
             runSemantic(semantic, c, tree, condition);
         }
 
+        bool isEnumClass;
+        Scope enumClassScope;
         bool isTemplateSpecializationHere;
         foreach (combination; iterateCombinations())
         {
@@ -856,6 +858,9 @@ void runSemantic(ref SemanticRunInfo semantic, ref Tree tree, Tree parent,
             if (wrappperInfo.flags & DeclarationFlags.friend)
                 continue;
 
+            if (classSpecifierInfo.key.among("enum class", "enum struct"))
+                isEnumClass = true;
+
             Tree parent2 = getRealParent(realParent, semantic);
             size_t parent3Index;
             Tree parent3 = getRealParent(parent2, semantic, &parent3Index);
@@ -930,7 +935,8 @@ void runSemantic(ref SemanticRunInfo semantic, ref Tree tree, Tree parent,
                 }
             }
 
-            if (tree.nonterminalID == ParserWrapper.nonterminalIDFor!"ClassSpecifier")
+            if (tree.nonterminalID == ParserWrapper.nonterminalIDFor!"ClassSpecifier"
+                || (tree.nonterminalID == ParserWrapper.nonterminalIDFor!"EnumSpecifier" && isEnumClass))
             {
                 Scope classScope;
                 if (tree !in targetScope.childScopeByTree)
@@ -945,37 +951,42 @@ void runSemantic(ref SemanticRunInfo semantic, ref Tree tree, Tree parent,
                     classScope.scopeCondition = semantic.logicSystem.or(classScope.scopeCondition,
                         instanceConditionHere);
                 }
+                if (tree.nonterminalID == ParserWrapper.nonterminalIDFor!"EnumSpecifier")
+                    enumClassScope = classScope;
                 if (classSpecifierInfo.className !in targetScope.subScopes)
                     targetScope.subScopes[classSpecifierInfo.className] = [];
                 targetScope.subScopes[classSpecifierInfo.className].addOnce(
                     targetScope.childScopeByTree[tree]);
                 classScope.className.add(ppVersion.condition,
                     classSpecifierInfo.className, semantic.logicSystem);
 
-                size_t startIndex = 0;
-                foreach (s; templateScopes)
-                    startIndex = classScope.extraParentScopes.add(ppVersion.condition,
-                        ExtraScope(ExtraScopeType.template_, s), ppVersion.logicSystem, startIndex)
-                        + 1;
-                foreach (t; classSpecifierInfo.parentTypes)
+                if (tree.nonterminalID == ParserWrapper.nonterminalIDFor!"ClassSpecifier")
                 {
-                    t = chooseType(t, ppVersion, true);
-                    if (t.kind == TypeKind.record)
+                    size_t startIndex = 0;
+                    foreach (s; templateScopes)
+                        startIndex = classScope.extraParentScopes.add(ppVersion.condition,
+                            ExtraScope(ExtraScopeType.template_, s), ppVersion.logicSystem, startIndex)
+                            + 1;
+                    foreach (t; classSpecifierInfo.parentTypes)
                     {
-                        RecordType recordType = cast(RecordType) t.type;
+                        t = chooseType(t, ppVersion, true);
+                        if (t.kind == TypeKind.record)
+                        {
+                            RecordType recordType = cast(RecordType) t.type;
 
-                        Scope scope_ = scopeForRecord(recordType, ppVersion, semantic);
+                            Scope scope_ = scopeForRecord(recordType, ppVersion, semantic);
 
-                        if (scope_ !is null && scope_.tree !is tree)
-                            startIndex = classScope.extraParentScopes.add(ppVersion.condition,
-                                ExtraScope(ExtraScopeType.parentClass, scope_),
-                                ppVersion.logicSystem, startIndex) + 1;
+                            if (scope_ !is null && scope_.tree !is tree)
+                                startIndex = classScope.extraParentScopes.add(ppVersion.condition,
+                                    ExtraScope(ExtraScopeType.parentClass, scope_),
+                                    ppVersion.logicSystem, startIndex) + 1;
+                        }
                     }
+                    if (classSpecifierInfo.namespaces.length && targetScope2 !is null)
+                        startIndex = classScope.extraParentScopes.add(ppVersion.condition,
+                            ExtraScope(ExtraScopeType.namespace, targetScope2),
+                            ppVersion.logicSystem, startIndex) + 1;
                 }
-                if (classSpecifierInfo.namespaces.length && targetScope2 !is null)
-                    startIndex = classScope.extraParentScopes.add(ppVersion.condition,
-                        ExtraScope(ExtraScopeType.namespace, targetScope2),
-                        ppVersion.logicSystem, startIndex) + 1;
             }
 
             DeclarationKey dk;
@@ -992,6 +1003,8 @@ void runSemantic(ref SemanticRunInfo semantic, ref Tree tree, Tree parent,
                 dk.flags |= DeclarationFlags.friend;
             if (targetScope.currentlyInsideParams)
                 dk.flags |= DeclarationFlags.templateParam;
+            if (isEnumClass)
+                dk.flags |= DeclarationFlags.enumClass;
             dk.name = classSpecifierInfo.className;
             dk.scope_ = targetScope;
 
@@ -1059,9 +1072,22 @@ void runSemantic(ref SemanticRunInfo semantic, ref Tree tree, Tree parent,
             }
         }
 
-        foreach (ref c; tree.childs[headChilds .. $])
+        if (tree.nonterminalID == ParserWrapper.nonterminalIDFor!"EnumSpecifier" && enumClassScope !is null)
         {
-            runSemantic(semantic, c, tree, condition);
+            SemanticRunInfo semanticRun = semantic;
+            semanticRun.currentScope = enumClassScope;
+
+            foreach (ref c; tree.childs[headChilds .. $])
+            {
+                runSemantic(semanticRun, c, tree, condition);
+            }
+        }
+        else
+        {
+            foreach (ref c; tree.childs[headChilds .. $])
+            {
+                runSemantic(semantic, c, tree, condition);
+            }
         }
     }, (MatchNonterminals!("OriginalNamespaceDefinition")) {
         string name = tree.childs[2].content;

src/cppconv/dwriter.d

@@ -4473,7 +4473,17 @@ void parseTreeToDCode(T)(ref CodeWriter code, DWriterData data, T tree, immutabl
                     string declName = typeToCode(semantic.extraInfo(tree).type,
                             data, newCondition, contextScope, tree.location, [], codeType);
 
-                    if (declName != "")
+                    bool isEnumClass;
+                    QualType enumType = chooseType(e.data.type2, ppVersion, true);
+                    if (enumType.kind == TypeKind.record)
+                    {
+                        RecordType recordType = cast(RecordType) enumType.type;
+                        foreach (e2; recordType.declarationSet.entries)
+                            if (e2.data.flags & DeclarationFlags.enumClass)
+                                isEnumClass = true;
+                    }
+
+                    if (declName != "" && !isEnumClass)
                     {
                         realId.add(newCondition,
                                 declName ~ "." ~ replaceKeywords(tree.childs[0].content),

tests/single/test378.cpp

@@ -0,0 +1,30 @@
+class FileNotFound;
+
+class QPdfDocument
+{
+public:
+    enum class Status {
+        Null,
+        Loading,
+        Ready,
+        Unloading,
+        Error
+    };
+
+    enum class Error {
+        None,
+        Unknown,
+        DataNotYetAvailable,
+        FileNotFound,
+        InvalidFileFormat,
+        IncorrectPassword,
+        UnsupportedSecurityScheme
+    };
+
+    Error load();
+
+    Status status() const;
+};
+
+QPdfDocument::Status s1 = QPdfDocument::Status::Ready;
+QPdfDocument::Error e1 = QPdfDocument::Error::Unknown;

tests/single/test378.d

@@ -0,0 +1,36 @@
+module test378;
+
+import config;
+import cppconvhelpers;
+
+extern(C++, class) struct FileNotFound;
+
+extern(C++, class) struct QPdfDocument
+{
+public:
+    enum /+ class +/ Status {
+        Null,
+        Loading,
+        Ready,
+        Unloading,
+        Error
+    }
+
+    enum /+ class +/ Error {
+        None,
+        Unknown,
+        DataNotYetAvailable,
+        FileNotFound,
+        InvalidFileFormat,
+        IncorrectPassword,
+        UnsupportedSecurityScheme
+    }
+
+    Error load();
+
+    Status status() const;
+}
+
+__gshared QPdfDocument.Status s1 = QPdfDocument.Status.Ready;
+__gshared QPdfDocument.Error e1 = QPdfDocument.Error.Unknown;
+