Changeset 728 in dev for trunk/ab5.0/abdev/BasicCompiler_Common

Timestamp:

Aug 21, 2008, 11:02:07 PM (16 years ago)

Author:

dai

Message:

#200への対応。ジェネリックインターフェイスを実装したジェネリッククラスのテンプレート展開に対応。

Location:

trunk/ab5.0/abdev/BasicCompiler_Common

Files:

• include/LexicalAnalyzer.h (modified) (2 diffs)
• src/LexicalAnalyzer_Class.cpp (modified) (15 diffs)

trunk/ab5.0/abdev/BasicCompiler_Common/include/LexicalAnalyzer.h

@@ -35 +35 @@
     static Member *CreateMember( const CClass &_class, Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine );
     static void AddMethod(CClass *pobj_c, UserProc *pUserProc, Prototype::Accessibility accessibility, BOOL bStatic, bool isConst, bool isAbstract,
-        bool isVirtual, bool isOverride, const char *interfaceName, bool isAutoGeneration, int nowLine);
+        bool isVirtual, bool isOverride, bool isEnableOverrideCheck, const char *interfaceName, bool isAutoGeneration, int nowLine);
     static bool Inherits( CClass &_class, const char *inheritNames, int nowLine );
-    static void Implements( CClass &_class, Interface *pInterface, std::vector<DynamicMethod::OverrideResult> &overrideResults );
+    static void Implements( CClass &_class, Interface *pInterface );
     static bool Implements( CClass &_class, const char *interfaceNames, int nowLine );
     static void LookaheadClass( const std::string &className, Classes &classes );
@@ -44 +44 @@
 
     // テンプレート展開
+    static Type LexicalAnalyzer::TemplateExpand_ResolveType( const Type &baseType, const Types &actualTypes );
     static void TemplateExpand_ResolveMethod( const CMethod *pBaseMethod, const Types &actualTypes, CClass *pNewClass );
     static const CClass *TemplateExpand( CClass &_class, const Types &actualTypes );

trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Class.cpp

@@ -278 +278 @@
 
 void LexicalAnalyzer::AddMethod(CClass *pobj_c, UserProc *pUserProc, Prototype::Accessibility accessibility, BOOL bStatic, bool isConst, bool isAbstract,
-    bool isVirtual, bool isOverride, const char *interfaceName, bool isAutoGeneration, int nowLine)
+    bool isVirtual, bool isOverride, bool isEnableOverrideCheck, const char *interfaceName, bool isAutoGeneration, int nowLine)
 {
     if( isAutoGeneration )
@@ -353 +353 @@
     {
         DynamicMethod::OverrideResult result;
-        result.enumType = pMethodForOverride->Override( pUserProc, accessibility, isOverride );
+        result.enumType = pMethodForOverride->Override( pUserProc, accessibility, isEnableOverrideCheck ? isOverride : true );
         result.pMethod = pMethodForOverride;
         OverrideErrorCheck( result );
@@ -514 +514 @@
 }
 
-void LexicalAnalyzer::Implements( CClass &_class, Interface *pInterface, std::vector<DynamicMethod::OverrideResult> &overrideResults )
+void LexicalAnalyzer::Implements( CClass &_class, Interface *pInterface )
 {
+    // まずは継承されたインターフェイスを実装する
+    BOOST_FOREACH( ::Interface *pInheritsInterface, pInterface->GetClass().GetInterfaces() )
+    {
+        // TODO: actualTypeParametersの引渡し
+        Implements(
+            _class,
+            new ::Interface( &pInheritsInterface->GetClass(), pInterface->GetActualTypeParameters() )
+        );
+    }
+
     _class.AddInterface( pInterface );
 
@@ -530 +540 @@
             result.enumType = pMethodForOverride->Override( &pMethod->GetUserProc(), pMethod->GetAccessibility(), false );
             result.pMethod = pMethod;
-            overrideResults.push_back( result );
+
+            OverrideErrorCheck( result );
 
             // 実装元になるメソッドは呼び出し不可にしておく（オーバーロードの解決から除外する）
@@ -588 +599 @@
             false,          // isVirtual
             false,          // isOverride
+            true,           // Override修飾子チェック
             "",
             true,           // isAutoGeneration
@@ -633 +645 @@
         if( pInterfaceClass->IsInterface() || pInterfaceClass->IsComInterface() )
         {
-            // インターフェイスを継承する
-            std::vector<DynamicMethod::OverrideResult> overrideResults;
-            Implements(
-                _class,
-                new ::Interface( pInterfaceClass, actualTypeParameters ),
-                overrideResults
-            );
-
-            // エラーチェック
-            BOOST_FOREACH( const DynamicMethod::OverrideResult result, overrideResults )
-            {
-                OverrideErrorCheck( result );
+            // インターフェイスを実装する
+            {
+                Implements(
+                    _class,
+                    new ::Interface( pInterfaceClass, actualTypeParameters )
+                );
             }
         }
@@ -844 +850 @@
 
                 //継承させる
-                if( !pobj_c->InheritsClass( *pInheritsClass, actualTypeParameters, i ) ){
+                if( !pobj_c->InheritsInterface( *pInheritsClass, actualTypeParameters, i ) ){
                     goto Interface_InheritsError;
                 }
@@ -934 +940 @@
                         true,               // isVirtual
                         false,              // isOverride
+                        true,               // Override修飾子チェック
                         interfaceName,
                         false,              // isAutoGeneration
@@ -1270 +1277 @@
                             isVirtual,
                             isOverride,
+                            true,               // Override修飾子チェック
                             interfaceName,
                             false,
@@ -1345 +1353 @@
 }
 
+Type LexicalAnalyzer::TemplateExpand_ResolveType( const Type &baseType, const Types &actualTypes )
+{
+    if( baseType.IsNull() )
+    {
+        return baseType;
+    }
+
+    Type resultType( baseType );
+    if( resultType.IsTypeParameter() )
+    {
+        // 型パラメータだったとき
+        resultType = actualTypes[baseType.GetFormalTypeIndex()];
+    }
+    else if( resultType.IsObject() || resultType.IsInterface() )
+    {
+        // クラス・インターフェイスだったとき
+        const CClass *pExpandedClass = TemplateExpand( *const_cast<CClass *>(&baseType.GetClass()), actualTypes );
+        resultType.SetClassPtr( pExpandedClass );
+    }
+
+    resultType.SetPtrLevel( baseType.PtrLevel() );
+
+    return resultType;
+}
+
 void LexicalAnalyzer::TemplateExpand_ResolveMethod( const CMethod *pBaseMethod, const Types &actualTypes, CClass *pNewClass )
 {
@@ -1376 +1409 @@
 
     // 戻り値のジェネリック型を解決
-    if( pUserProc->ReturnType().IsTypeParameter() )
-    {
-        Type type = actualTypes[pUserProc->ReturnType().GetFormalTypeIndex()];
-        type.SetPtrLevel( pUserProc->ReturnType().PtrLevel() );
-        pUserProc->SetReturnType( type );
-    }
+    pUserProc->SetReturnType( TemplateExpand_ResolveType( pUserProc->ReturnType(), actualTypes ) );
 
     compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
@@ -1394 +1422 @@
         pBaseMethod->IsAbstract(),
         pBaseMethod->IsVirtual(),
-        false,
+        false,                      // isOverride
+        false,                      // Override修飾子チェック
         "",
         false,
@@ -1403 +1432 @@
 const CClass *LexicalAnalyzer::TemplateExpand( CClass &_class, const Types &actualTypes )
 {
+    // そもそもジェネリック型ではないとき
+    if( !_class.IsGeneric() )
+    {
+        return &_class;
+    }
+
     // 展開済みのクラスがあればそれを返す
     BOOST_FOREACH( const ExpandedTemplateClass *pExpandedTemplateClass, _class.expandedTemplateClasses )
@@ -1431 +1466 @@
     );
 
+    // 展開済みクラスとして登録
+    _class.expandedTemplateClasses.push_back( new ExpandedTemplateClass( pNewClass, actualTypes ) );
+
     // 基底クラス
-    pNewClass->SetSuperClass( &_class.GetSuperClass() );
+    if( _class.HasSuperClass() )
+    {
+        const CClass *pExpandedSuperClass = TemplateExpand( *const_cast<CClass *>(&_class.GetSuperClass()), actualTypes );
+        pNewClass->InheritsClass( *pExpandedSuperClass, pNewClass->GetSuperClassActualTypeParameters(), -1 );
+    }
 
     // インターフェイスのジェネリック型を解決
     BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
     {
-        pNewClass->AddInterface( new ::Interface( &pInterface->GetClass(), actualTypes ) );
+        const CClass *pExpandedInterfaceClass = TemplateExpand( *const_cast<CClass *>(&pInterface->GetClass()), actualTypes );
+        Interface *pExpandedInterface = new ::Interface( pExpandedInterfaceClass, actualTypes );
+        pNewClass->AddInterface( pExpandedInterface );
+
+        // インターフェイス メソッドのジェネリック型を解決
+        BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
+        {
+            if( pMethod->GetUserProc().GetParentClassPtr() == &_class )
+            {
+                // ターゲットクラス内で実装されるメソッドの場合
+                TemplateExpand_ResolveMethod( pMethod, actualTypes, pNewClass );
+            }
+        }
+
+        /////////////////////////////////
+        // オーバーライドチェック
+        /////////////////////////////////
+        if( pExpandedInterface->GetDynamicMethods().size() != pInterface->GetDynamicMethods().size() )
+        {
+            Jenga::Throw( "インターフェイス メソッドのジェネリック型の解決に失敗している" );
+        }
+        else
+        {
+            for( int i=0; i<pInterface->GetDynamicMethods().size(); i++ )
+            {
+                if( pInterface->GetDynamicMethods()[i]->IsAbstract() != pExpandedInterface->GetDynamicMethods()[i]->IsAbstract() )
+                {
+                    Jenga::Throw( "テンプレート展開時のオーバーライドに失敗している … " + pInterface->GetDynamicMethods()[i]->GetUserProc().GetFullName() );
+                }
+            }
+        }
     }
 
@@ -1461 +1533 @@
         if( pMethod->GetUserProc().GetParentClassPtr() == &_class )
         {
-            // ターゲットクラス内で実装されるメソッドの場合
-
+            // ターゲットクラス内で実装されるメソッドの場合のみ（その他のメソッドはInheritsClassで継承されているはず）
             TemplateExpand_ResolveMethod( pMethod, actualTypes, pNewClass );
         }
-        else
-        {
-            DynamicMethod *pNewDynamicMethod = new DynamicMethod( *pMethod );
-            pNewClass->GetDynamicMethods().push_back( pNewDynamicMethod );
-        }
-    }
-
-    // インターフェイス メソッドのジェネリック型を解決
-    BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
-    {
-        BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
-        {
-            TemplateExpand_ResolveMethod( pMethod, actualTypes, pNewClass );
-        }
     }
 
     pNewClass->SetVtblNum( _class.GetVtblNum() );
-
-    // 展開済みクラスとして登録
-    _class.expandedTemplateClasses.push_back( new ExpandedTemplateClass( pNewClass, actualTypes ) );
 
     pNewClass->Readed();