Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++ #include <QtCore>
++
++ class Class : public QObject
++ {
++ Q_OBJECT
++
++ class SubClass
++ {
++ void f()
++ {
++ tr("nested class context");
++ }
++ };
++
++ void f()
++ {
++ tr("just class context");
++ }
++ };
++
++ namespace Outer {
++
++ class Class : public QObject { Q_OBJECT };
++
++ namespace Middle1 {
++
++ class Class : public QObject { Q_OBJECT };
++
++ namespace Inner1 {
++
++ class Class : public QObject { Q_OBJECT };
++
++ }
++
++ namespace I = Inner1;
++
++ class Something;
++ class Different;
++
++ }
++
++ namespace Middle2 {
++
++ class Class : public QObject { Q_OBJECT };
++
++ namespace Inner2 {
++
++ class Class : public QObject { Q_OBJECT };
++
++ namespace IO = Middle2;
++
++ }
++
++ namespace I = Inner2;
++
++ }
++
++ namespace MI = Middle1::Inner1;
++
++ namespace O = ::Outer;
++
++ class Middle1::Different : QObject {
++ Q_OBJECT
++ void f() {
++ tr("different namespaced class def");
++ }
++ };
++
++ }
++
++ namespace O = Outer;
++ namespace OM = Outer::Middle1;
++ namespace OMI = Outer::Middle1::I;
++
++ int main()
++ {
++ Class::tr("outestmost class");
++ Outer::Class::tr("outer class");
++ Outer::MI::Class::tr("innermost one");
++ OMI::Class::tr("innermost two");
++ O::Middle1::I::Class::tr("innermost three");
++ O::Middle2::I::Class::tr("innermost three b");
++ OM::I::Class::tr("innermost four");
++ return 0;
++ }
++
++ class OM::Something : QObject {
++ Q_OBJECT
++ void f() {
++ tr("namespaced class def");
++ }
++ void g() {
++ tr("namespaced class def 2");
++ }
++ };
++
++ // QTBUG-8360
++ namespace A {
++
++ void foo()
++ {
++ using namespace A;
++ }
++
++ QString goo()
++ {
++ return QObject::tr("Bla");
++ }
++
++ }
++
++
++ namespace AA {
++ namespace B {
++
++ using namespace AA;
++
++ namespace C {
++
++ class Test : public QObject {
++ Q_OBJECT
++ };
++
++ }
++
++ }
++
++ using namespace B;
++ using namespace C;
++
++ void goo()
++ {
++ AA::Test::tr("howdy?");
++ }
++
++ }
++
++
++ namespace A1 {
++ namespace B {
++
++ class Test : public QObject {
++ Q_OBJECT
++ };
++
++ using namespace A1;
++
++ void foo()
++ {
++ B::B::B::Test::tr("yeeee-ha!");
++ }
++
++ }
++ }
++
++ namespace Ns1::Ns2::Ns3 {
++ class Cl: public QObject {
++ Q_OBJECT
++ void func1();
++ void func2();
++ void func3();
++ void func4();
++ };
++
++ // inside namespace
++
++ void Cl::func1() {
++ tr("message1");
++ }
++
++ void Ns3::Cl::func2() {
++ tr("message2");
++ }
++
++ void Ns2::Ns3::Cl::func3() {
++ tr("message3");
++ }
++
++ void Ns1::Ns2::Ns3::Cl::func4() {
++ tr("message4");
++ }
++ }
++
++ class cl: public QObject {
++ Q_OBJECT
++ void func();
++ };
++
++ void ::cl::func() {
++ tr("text");
++ }
++
++ // using namespace in parent
++ namespace A1 {
++ namespace A2 {
++ class Cl : public QObject
++ {
++ Q_OBJECT
++ void func();
++ };
++ } // namespace A2
++ } // namespace A1
++
++ using namespace A1::A2;
++
++ namespace A1 {
++ void Cl::func()
++ {
++ tr("using namespace in parent");
++ }
++ } // namespace A1
++
++ // variable template
++
++ namespace NS1 {
++ namespace NS2 {
++
++ template <class T>
++ struct Cl1
++ {
++ static constexpr bool value = true;
++ };
++
++ template <class T>
++ constexpr bool varTemplate = NS2::Cl1<T>::value;
++
++ } // namespace NS2
++ } // namespace NS1
++
++ class Cl2 : public QObject
++ {
++ Q_OBJECT
++ void func() { tr("context after variable template"); }
++ };
++
++ // Direct match in parent namespace must win over using directive match
++ namespace EdgeTest1 {
++ namespace Inner {
++ class Tr : public QObject { Q_OBJECT };
++ }
++ namespace Outer {
++ class Tr : public QObject { Q_OBJECT };
++
++ namespace Deep {
++ using namespace EdgeTest1::Inner;
++
++ void test()
++ {
++ Tr::tr("direct parent wins over using");
++ }
++ }
++ }
++ }
++
++ // Reusing same using directive for each segment in qualified name
++ namespace EdgeTest3 {
++ namespace Level1 {
++ namespace Level2 {
++ namespace Level3 {
++ class Test : public QObject { Q_OBJECT };
++ }
++ }
++ }
++ namespace Container {
++ using namespace EdgeTest3::Level1;
++
++ void test()
++ {
++ Level2::Level3::Test::tr("reuse using per segment");
++ }
++ }
++ }
++
++ // Multiple using directives with same target
++ namespace EdgeTest4 {
++ namespace Target {
++ class Tr : public QObject { Q_OBJECT };
++ }
++ namespace Middle1 {
++ using namespace EdgeTest4::Target;
++ }
++ namespace Middle2 {
++ using namespace EdgeTest4::Target;
++ }
++ namespace Container {
++ using namespace EdgeTest4::Middle1;
++ using namespace EdgeTest4::Middle2;
++
++ void test()
++ {
++ Tr::tr("prevent duplicate visits");
++ }
++ }
++ }
++
++ // Direct child in current namespace beats using directive in same namespace
++ namespace EdgeTest5 {
++ namespace External {
++ class Tr : public QObject { Q_OBJECT };
++ }
++ namespace MySpace {
++ using namespace EdgeTest5::External;
++ class Tr : public QObject { Q_OBJECT };
++
++ void test()
++ {
++ Tr::tr("direct child beats using");
++ }
++ }
++ }
++
++ // Test visitedUsings sharing across loop iterations
++ // Same using directive at different namespace levels
++ namespace EdgeTest6 {
++ namespace Target {
++ class Tr : public QObject { Q_OBJECT };
++ }
++ namespace Parent {
++ using namespace EdgeTest6::Target;
++
++ namespace Child {
++ using namespace EdgeTest6::Target;
++
++ void test()
++ {
++ Tr::tr("same using at different levels");
++ }
++ }
++ }
++ }
++
++ // Different paths to same namespace via using directives
++ namespace EdgeTest7 {
++ namespace Common {
++ class Tr : public QObject { Q_OBJECT };
++ }
++ namespace PathA {
++ using namespace EdgeTest7::Common;
++ }
++ namespace PathB {
++ using namespace EdgeTest7::Common;
++ }
++ namespace Container {
++ using namespace EdgeTest7::PathA;
++
++ namespace Inner {
++ using namespace EdgeTest7::PathB;
++
++ void test()
++ {
++ Tr::tr("different paths to same namespace");
++ }
++ }
++ }
++ }
++
++ // Using directive at inner level shouldn't block outer level direct match
++ namespace EdgeTest8 {
++ namespace Decoy {
++ class Tr : public QObject { Q_OBJECT };
++ }
++ namespace Outer {
++ class Tr : public QObject { Q_OBJECT };
++
++ namespace Inner {
++ using namespace EdgeTest8::Decoy;
++
++ void test()
++ {
++ Tr::tr("inner using shouldn't block outer direct");
++ }
++ }
++ }
++ }
++
++ // Nested using directives with shared visitedUsings
++ namespace EdgeTest9 {
++ namespace Level1 {
++ class Tr : public QObject { Q_OBJECT };
++ }
++ namespace Level2 {
++ using namespace EdgeTest9::Level1;
++ }
++ namespace Level3 {
++ using namespace EdgeTest9::Level2;
++
++ namespace Level4 {
++ using namespace EdgeTest9::Level1;
++
++ void test()
++ {
++ Tr::tr("nested using with shared visited");
++ }
++ }
++ }
++ }
++
++ // QTBUG-140550: Class with same name as enclosing namespace
++ namespace Test {
++ class Test : public QObject {
++ Q_OBJECT
++ public:
++ Test();
++ };
++
++ Test::Test() {
++ tr("class same name as namespace");
++ }
++ } // namespace Test
++
++ // QTBUG-140550: Nested namespaces with same name, class with different name
++ namespace NsA {
++ namespace NsA {
++ namespace NsA {
++ class MyClass : public QObject {
++ Q_OBJECT
++ public:
++ void func1();
++ void func2();
++ };
++
++ void MyClass::func1() {
++ tr("nested same-name ns, different class 1");
++ }
++
++ void NsA::MyClass::func2() {
++ tr("nested same-name ns, different class 2");
++ }
++ } // namespace NsA
++ } // namespace NsA
++ } // namespace NsA
++
++ // QTBUG-140550: Complex nesting - namespace A inside namespace B inside namespace A
++ namespace Alpha {
++ namespace Beta {
++ namespace Alpha {
++ class Widget : public QObject {
++ Q_OBJECT
++ public:
++ void method();
++ };
++
++ void Widget::method() {
++ tr("complex nesting different names");
++ }
++ } // namespace Alpha
++ } // namespace Beta
++ } // namespace Alpha
++
++ // Combined bug test: Same-named class with using directive (QTBUG-140548 + QTBUG-140550)
++ namespace CombinedTest1 {
++ namespace ExternalLib {
++ class Tr : public QObject {
++ Q_OBJECT
++ public:
++ void externalFunc() { tr("external lib tr"); }
++ };
++ }
++
++ namespace MyApp {
++ using namespace CombinedTest1::ExternalLib;
++
++ // Same name as enclosing namespace AND there's a using directive
++ class MyApp : public QObject {
++ Q_OBJECT
++ public:
++ void myFunc()
++ {
++ // Should resolve to MyApp::MyApp (the class), not ExternalLib::Tr
++ tr("combined test: direct class wins");
++ }
++ };
++
++ namespace Inner {
++ void testFunc()
++ {
++ // Qualified call - should prefer the class with same parent namespace
++ MyApp::tr("combined test: qualified same name");
++ }
++ }
++ }
++ }
++
++ // Deeply nested same-name namespaces with using directive
++ namespace CombinedTest2 {
++ namespace Level {
++ namespace Level {
++ class Helper : public QObject {
++ Q_OBJECT
++ public:
++ void helperMethod() { tr("helper in Level::Level"); }
++ };
++
++ namespace Level {
++ using namespace CombinedTest2::Level::Level;
++
++ class Level : public QObject {
++ Q_OBJECT
++ public:
++ void method()
++ {
++ // Should resolve to Level::Level::Level::Level (the class)
++ tr("deeply nested same name with using");
++ }
++ };
++
++ void freeFunc()
++ {
++ // Should prefer the local class
++ Level::tr("qualified deeply nested");
++
++ // Should find Helper via using directive
++ Helper::tr("helper via using in nested");
++ }
++ }
++ }
++ }
++ }
++
++ // Using directive shadowing local namespace
++ namespace CombinedTest3 {
++ namespace Container {
++ class Data : public QObject {
++ Q_OBJECT
++ public:
++ void process() { tr("data in original container"); }
++ };
++ }
++
++ namespace Outer {
++ using namespace CombinedTest3::Container;
++
++ namespace Container {
++ // Local namespace named Container, but there's also a using directive
++ class Item : public QObject {
++ Q_OBJECT
++ public:
++ void method()
++ {
++ // Should find Item in local Outer::Container
++ tr("item in local container");
++ }
++ };
++
++ void testFunc()
++ {
++ // Should resolve to local namespace
++ Item::tr("qualified local item");
++
++ // Should still find Data via using directive
++ Data::tr("data via using directive");
++ }
++ }
++ }
++ }
++
++ //#include "main.moc"