Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Class.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Class.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Class.cpp	(revision 640)
@@ -869,10 +869,10 @@
 }
 
-bool CClass::Resolve( const ObjectModule &resolver )
+bool CClass::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
 	// 型パラメータ
 	BOOST_FOREACH( GenericType &genericType, formalGenericTypes )
 	{
-		genericType.GetType().Resolve( resolver );
+		genericType.GetType().Resolve( resolver, resolveErrors );
 	}
 
@@ -882,5 +882,13 @@
 		if( this->pSuperClass->IsNeedResolve() )
 		{
-			this->pSuperClass = resolver.meta.GetClasses().FindEx( *pSuperClass );
+			const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pSuperClass );
+			if( pTempClass )
+			{
+				this->pSuperClass = pTempClass;
+			}
+			else
+			{
+				resolveErrors.Add( ResolveError( this->pSuperClass->GetRelationalObjectModuleIndex(), this->pSuperClass->GetFullName() ) );
+			}
 		}
 	}
@@ -889,14 +897,14 @@
 	BOOST_FOREACH( Type &superClassActualTypeParameter, superClassActualTypeParameters )
 	{
-		superClassActualTypeParameter.Resolve( resolver );
+		superClassActualTypeParameter.Resolve( resolver, resolveErrors );
 	}
 
 	// Blittable型情報
-	blittableType.Resolve( resolver );
+	blittableType.Resolve( resolver, resolveErrors );
 
 	// 実装するインターフェイス
 	BOOST_FOREACH( ::Interface *pInterface, interfaces )
 	{
-		pInterface->Resolve( resolver );
+		pInterface->Resolve( resolver, resolveErrors );
 	}
 
@@ -904,5 +912,5 @@
 	BOOST_FOREACH( Member *pMember, dynamicMembers )
 	{
-		pMember->Resolve( resolver );
+		pMember->Resolve( resolver, resolveErrors );
 	}
 
@@ -910,5 +918,5 @@
 	BOOST_FOREACH( Member *pMember, staticMembers )
 	{
-		pMember->Resolve( resolver );
+		pMember->Resolve( resolver, resolveErrors );
 	}
 
@@ -916,5 +924,5 @@
 	BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
 	{
-		pMethod->Resolve( resolver );
+		pMethod->Resolve( resolver, resolveErrors );
 	}
 
@@ -922,5 +930,5 @@
 	BOOST_FOREACH( CMethod *pMethod, staticMethods )
 	{
-		pMethod->Resolve( resolver );
+		pMethod->Resolve( resolver, resolveErrors );
 	}
 
@@ -928,5 +936,5 @@
 	BOOST_FOREACH( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, expandedTemplateClasses )
 	{
-		pExpandedTemplateClass->Resolve( resolver );
+		pExpandedTemplateClass->Resolve( resolver, resolveErrors );
 	}
 
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Const.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Const.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Const.cpp	(revision 640)
@@ -7,7 +7,7 @@
 }
 
-bool CConst::Resolve( const ObjectModule &resolver )
+bool CConst::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-	type.Resolve( resolver );
+	type.Resolve( resolver, resolveErrors );
 	return true;
 }
@@ -78,5 +78,5 @@
 }
 
-bool ConstMacro::Resolve( const ObjectModule &resolver )
+bool ConstMacro::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
 	// 依存関係を解決すべきメンバは無い
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/DataTable.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/DataTable.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/DataTable.cpp	(revision 640)
@@ -78,9 +78,9 @@
 }
 
-void DataTable::Resolve( const ObjectModule &resolver )
+void DataTable::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
 	BOOST_FOREACH( Schedule &schedule, schedules )
 	{
-		schedule.Resolve( resolver );
+		schedule.Resolve( resolver, resolveErrors );
 	}
 }
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Delegate.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Delegate.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Delegate.cpp	(revision 640)
@@ -19,11 +19,11 @@
 }
 
-bool Delegate::Resolve( const ObjectModule &resolver )
+bool Delegate::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-	Procedure::Resolve( resolver );
+	Procedure::Resolve( resolver, resolveErrors );
 
 	BOOST_FOREACH( Parameter *pParameter, dynamicParams )
 	{
-		pParameter->Resolve( resolver );
+		pParameter->Resolve( resolver, resolveErrors );
 	}
 
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Interface.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Interface.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Interface.cpp	(revision 640)
@@ -33,4 +33,22 @@
 }
 
+bool Interface::Equals( const Interface *pInterface ) const
+{
+	// ポインタが等しいかどうかを見てみる
+	if( this == pInterface )
+	{
+		return true;
+	}
+	else if( this->pInterfaceClass->IsNeedResolve() || pInterface->pInterfaceClass->IsNeedResolve() )
+	{
+		// 依存関係解決前の状態であれば、パスが等しいかどうかを見てみる
+		if( this-pInterfaceClass->IsDuplication( pInterface->pInterfaceClass ) )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
 std::string Interface::GetFullNameWithActualGenericTypeParameters() const
 {
@@ -53,10 +71,10 @@
 }
 
-bool Interface::Resolve( const ObjectModule &resolver )
+bool Interface::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
 	// 動的メソッド
 	BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
 	{
-		pMethod->Resolve( resolver );
+		pMethod->Resolve( resolver, resolveErrors );
 	}
 
@@ -66,5 +84,13 @@
 		if( this->pInterfaceClass->IsNeedResolve() )
 		{
-			this->pInterfaceClass = resolver.meta.GetClasses().FindLike( pInterfaceClass );
+			const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pInterfaceClass );
+			if( pTempClass )
+			{
+				this->pInterfaceClass = pTempClass;
+			}
+			else
+			{
+				resolveErrors.Add( ResolveError( this->pInterfaceClass->GetRelationalObjectModuleIndex(), this->pInterfaceClass->GetFullName() ) );
+			}
 		}
 	}
@@ -72,5 +98,5 @@
 	BOOST_FOREACH( Type &actualTypeParameter, actualTypeParameters )
 	{
-		actualTypeParameter.Resolve( resolver );
+		actualTypeParameter.Resolve( resolver, resolveErrors );
 	}
 
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Member.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Member.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Member.cpp	(revision 640)
@@ -41,7 +41,7 @@
 }
 
-bool Member::Resolve( const ObjectModule &resolver )
+bool Member::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-	type.Resolve( resolver );
+	type.Resolve( resolver, resolveErrors );
 	return true;
 }
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Meta.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Meta.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Meta.cpp	(revision 640)
@@ -253,5 +253,5 @@
 }
 
-void Meta::Resolve( const ObjectModule &resolver )
+void Meta::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
 	// 関数・メソッド
@@ -261,5 +261,5 @@
 	{
 		UserProc *pUserProc = this->GetUserProcs().Iterator_GetNext();
-		pUserProc->Resolve( resolver );
+		pUserProc->Resolve( resolver, resolveErrors );
 	}
 
@@ -270,5 +270,5 @@
 	{
 		DllProc *pDllProc = this->GetDllProcs().Iterator_GetNext();
-		pDllProc->Resolve( resolver );
+		pDllProc->Resolve( resolver, resolveErrors );
 	}
 
@@ -279,5 +279,5 @@
 	{
 		CClass *pClass = this->GetClasses().Iterator_GetNext();
-		pClass->Resolve( resolver );
+		pClass->Resolve( resolver, resolveErrors );
 	}
 
@@ -285,5 +285,5 @@
 	BOOST_FOREACH( Variable *pVar, globalVars )
 	{
-		pVar->Resolve( resolver );
+		pVar->Resolve( resolver, resolveErrors );
 	}
 
@@ -294,5 +294,5 @@
 	{
 		CConst *pConst = this->GetGlobalConsts().Iterator_GetNext();
-		pConst->Resolve( resolver );
+		pConst->Resolve( resolver, resolveErrors );
 	}
 
@@ -303,5 +303,11 @@
 	{
 		ConstMacro *pConstMacro = this->GetGlobalConstMacros().Iterator_GetNext();
-		pConstMacro->Resolve( resolver );
+		pConstMacro->Resolve( resolver, resolveErrors );
+	}
+
+	// blittable型
+	BOOST_FOREACH( BlittableType &blittableType, blittableTypes )
+	{
+		blittableType.Resolve( resolver, resolveErrors );
 	}
 
@@ -309,5 +315,5 @@
 	BOOST_FOREACH( TypeDef &typeDef, typeDefs )
 	{
-		typeDef.Resolve( resolver );
+		typeDef.Resolve( resolver, resolveErrors );
 	}
 
@@ -315,5 +321,5 @@
 	BOOST_FOREACH( ProcPointer *pProcPointer, procPointers )
 	{
-		pProcPointer->Resolve( resolver );
+		pProcPointer->Resolve( resolver, resolveErrors );
 	}
 
@@ -324,5 +330,5 @@
 	{
 		Delegate *pDelegate = this->GetDelegates().Iterator_GetNext();
-		pDelegate->Resolve( resolver );
-	}
-}
+		pDelegate->Resolve( resolver, resolveErrors );
+	}
+}
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Method.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Method.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Method.cpp	(revision 640)
@@ -1,11 +1,19 @@
 #include "stdafx.h"
 
-bool CMethod::Resolve( const ObjectModule &resolver )
+bool CMethod::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-	if( pUserProc )
+	if( this->pUserProc )
 	{
-		if( pUserProc->IsNeedResolve() )
+		if( this->pUserProc->IsNeedResolve() )
 		{
-			pUserProc = resolver.meta.GetUserProcs().FindLike( pUserProc );
+			const UserProc *pTempUserProc = resolver.meta.GetUserProcs().FindLike( this->pUserProc );
+			if( pTempUserProc )
+			{
+				this->pUserProc = pTempUserProc;
+			}
+			else
+			{
+				resolveErrors.Add( ResolveError( this->pUserProc->GetRelationalObjectModuleIndex(), this->pUserProc->GetFullName() ) );
+			}
 		}
 	}
@@ -41,7 +49,7 @@
 }
 
-bool DynamicMethod::Resolve( const ObjectModule &resolver )
+bool DynamicMethod::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-	CMethod::Resolve( resolver );
+	CMethod::Resolve( resolver, resolveErrors );
 
 	if( this->pInheritsClass )
@@ -49,5 +57,13 @@
 		if( this->pInheritsClass->IsNeedResolve() )
 		{
-			this->pInheritsClass = resolver.meta.GetClasses().FindLike( pInheritsClass );
+			const CClass *pTempClass = resolver.meta.GetClasses().FindLike( pInheritsClass );
+			if( pTempClass )
+			{
+				this->pInheritsClass = pTempClass;
+			}
+			else
+			{
+				resolveErrors.Add( ResolveError( this->pInheritsClass->GetRelationalObjectModuleIndex(), this->pInheritsClass->GetFullName() ) );
+			}
 		}
 	}
@@ -62,7 +78,7 @@
 }
 
-bool StaticMethod::Resolve( const ObjectModule &resolver )
+bool StaticMethod::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-	CMethod::Resolve( resolver );
+	CMethod::Resolve( resolver, resolveErrors );
 	return true;
 }
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/NativeCode.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/NativeCode.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/NativeCode.cpp	(revision 640)
@@ -19,5 +19,5 @@
 }
 
-bool Schedule::Resolve( const ObjectModule &resolver )
+bool Schedule::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
 	switch( type )
@@ -26,13 +26,29 @@
 	case AddressOf:
 	case CatchAddress:
-		if( pUserProc->IsNeedResolve() )
-		{
-			pUserProc = resolver.meta.GetUserProcs().FindLike( pUserProc );
+		if( this->pUserProc->IsNeedResolve() )
+		{
+			const ::UserProc *pTempUserProc = resolver.meta.GetUserProcs().FindLike( this->pUserProc );
+			if( pTempUserProc )
+			{
+				this->pUserProc = pTempUserProc;
+			}
+			else
+			{
+				resolveErrors.Add( ResolveError( this->pUserProc->GetRelationalObjectModuleIndex(), this->pUserProc->GetFullName() ) );
+			}
 		}
 		break;
 	case DllProc:
-		if( pDllProc->IsNeedResolve() )
-		{
-			pDllProc = resolver.meta.GetDllProcs().FindLike( pDllProc );
+		if( this->pDllProc->IsNeedResolve() )
+		{
+			const ::DllProc *pTempDllProc = resolver.meta.GetDllProcs().FindLike( this->pDllProc );
+			if( pTempDllProc )
+			{
+				this->pDllProc = pTempDllProc;
+			}
+			else
+			{
+				resolveErrors.Add( ResolveError( this->pDllProc->GetRelationalObjectModuleIndex(), this->pDllProc->GetFullName() ) );
+			}
 		}
 		break;
@@ -40,7 +56,15 @@
 	case Vtbl:
 	case TypeInfo:
-		if( pClass->IsNeedResolve() )
-		{
-			pClass = resolver.meta.GetClasses().FindLike( pClass );
+		if( this->pClass->IsNeedResolve() )
+		{
+			const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pClass );
+			if( pTempClass )
+			{
+				this->pClass = pTempClass;
+			}
+			else
+			{
+				resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
+			}
 		}
 		break;
@@ -191,9 +215,9 @@
 }
 
-void NativeCode::Resolve( const ObjectModule &resolver )
+void NativeCode::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
 	BOOST_FOREACH( Schedule &schedule, schedules )
 	{
-		schedule.Resolve( resolver );
-	}
-}
+		schedule.Resolve( resolver, resolveErrors );
+	}
+}
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/ObjectModule.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/ObjectModule.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/ObjectModule.cpp	(revision 640)
@@ -77,7 +77,4 @@
 	}
 
-	// 依存関係を解決
-	this->Resolve();
-
 	// TODO: basbufがいらなくなったら消す
 	extern char *basbuf;
@@ -85,13 +82,13 @@
 }
 
-void ObjectModule::Resolve()
-{
-	this->meta.Resolve( *this );
+void ObjectModule::Resolve( ResolveErrors &resolveErrors )
+{
+	this->meta.Resolve( *this, resolveErrors );
 
 	// グローバルネイティブコードを解決（スケジュールを解決する）
-	this->globalNativeCode.Resolve( *this );
+	this->globalNativeCode.Resolve( *this, resolveErrors );
 
 	// データテーブルを解決（スケジュールを解決する）
-	this->dataTable.Resolve( *this );
+	this->dataTable.Resolve( *this, resolveErrors );
 }
 
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Procedure.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Procedure.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Procedure.cpp	(revision 640)
@@ -12,12 +12,12 @@
 }
 
-bool Procedure::Resolve( const ObjectModule &resolver )
+bool Procedure::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
 	BOOST_FOREACH( Parameter *pParameter, params )
 	{
-		pParameter->Resolve( resolver );
-	}
-
-	returnType.Resolve( resolver );
+		pParameter->Resolve( resolver, resolveErrors );
+	}
+
+	returnType.Resolve( resolver, resolveErrors );
 
 	return true;
@@ -170,13 +170,21 @@
 }
 
-bool UserProc::Resolve( const ObjectModule &resolver )
-{
-	Procedure::Resolve( resolver );
-
-	if( pParentClass )
-	{
-		if( pParentClass->IsNeedResolve() )
-		{
-			pParentClass = resolver.meta.GetClasses().FindLike( pParentClass );
+bool UserProc::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
+{
+	Procedure::Resolve( resolver, resolveErrors );
+
+	if( this->pParentClass )
+	{
+		if( this->pParentClass->IsNeedResolve() )
+		{
+			const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pParentClass );
+			if( pTempClass )
+			{
+				this->pParentClass = pTempClass;
+			}
+			else
+			{
+				resolveErrors.Add( ResolveError( this->pParentClass->GetRelationalObjectModuleIndex(), this->pParentClass->GetFullName() ) );
+			}
 		}
 	}
@@ -184,23 +192,23 @@
 	if( pInterface )
 	{
-		const_cast<Interface *>(pInterface)->Resolve( resolver );
+		const_cast<Interface *>(pInterface)->Resolve( resolver, resolveErrors );
 	}
 
 	if( pMethod )
 	{
-		pMethod->Resolve( resolver );
+		pMethod->Resolve( resolver, resolveErrors );
 	}
 
 	BOOST_FOREACH( Parameter *pParameter, realParams )
 	{
-		pParameter->Resolve( resolver );
+		pParameter->Resolve( resolver, resolveErrors );
 	}
 
 	BOOST_FOREACH( Variable *pLocalVar, localVars )
 	{
-		pLocalVar->Resolve( resolver );
-	}
-
-	nativeCode.Resolve( resolver );
+		pLocalVar->Resolve( resolver, resolveErrors );
+	}
+
+	nativeCode.Resolve( resolver, resolveErrors );
 	return true;
 }
@@ -228,13 +236,13 @@
 }
 
-bool DllProc::Resolve( const ObjectModule &resolver )
-{
-	Procedure::Resolve( resolver );
-	return true;
-}
-
-bool ProcPointer::Resolve( const ObjectModule &resolver )
-{
-	Procedure::Resolve( resolver );
+bool DllProc::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
+{
+	Procedure::Resolve( resolver, resolveErrors );
+	return true;
+}
+
+bool ProcPointer::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
+{
+	Procedure::Resolve( resolver, resolveErrors );
 	return true;
 }
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Template.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Template.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Template.cpp	(revision 640)
@@ -9,14 +9,22 @@
 }
 
-bool ExpandedTemplateClass::Resolve( const ObjectModule &resolver )
+bool ExpandedTemplateClass::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
 	if( pClass->IsNeedResolve() )
 	{
-		pClass = const_cast<CClass *>(resolver.meta.GetClasses().FindLike( pClass ));
+		CClass *pTempClass = const_cast<CClass *>(resolver.meta.GetClasses().FindLike( pClass ));
+		if( pTempClass )
+		{
+			this->pClass = pTempClass;
+		}
+		else
+		{
+			resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
+		}
 	}
 
 	BOOST_FOREACH( Type &actualType, actualTypes )
 	{
-		actualType.Resolve( resolver );
+		actualType.Resolve( resolver, resolveErrors );
 	}
 
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Type.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Type.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Type.cpp	(revision 640)
@@ -129,14 +129,24 @@
 bool Type::Equals( const Type &type ) const
 {
-	if( basicType == type.basicType ){
-		if( NATURAL_TYPE( basicType ) == DEF_OBJECT
-			|| NATURAL_TYPE( basicType ) == DEF_STRUCT ){
-
-				if( index == type.index ){
+	if( basicType == type.basicType )
+	{
+		if( NATURAL_TYPE( basicType ) == DEF_OBJECT || NATURAL_TYPE( basicType ) == DEF_STRUCT )
+		{
+			// ポインタが等しいかどうかを見てみる
+			if( this->pClass == type.pClass )
+			{
+				return true;
+			}
+			else if( this->pClass->IsNeedResolve() || type.pClass->IsNeedResolve() )
+			{
+				// 依存関係解決前の状態であれば、パスが等しいかどうかを見てみる
+				if( this->pClass->IsDuplication( type.pClass ) )
+				{
 					return true;
 				}
-
-		}
-		else{
+			}
+		}
+		else
+		{
 			return true;
 		}
@@ -556,5 +566,5 @@
 }
 
-bool Type::Resolve( const ObjectModule &resolver )
+bool Type::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
 	if( this->HasMember() )
@@ -562,10 +572,18 @@
 		if( this->pClass->IsNeedResolve() )
 		{
-			this->pClass = resolver.meta.GetClasses().FindLike( this->pClass );
+			const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pClass );
+			if( pTempClass )
+			{
+				this->pClass = pTempClass;
+			}
+			else
+			{
+				resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
+			}
 		}
 
 		BOOST_FOREACH( GenericType &actualGenericType, actualGenericTypes )
 		{
-			actualGenericType.GetType().Resolve( resolver );
+			actualGenericType.GetType().Resolve( resolver, resolveErrors );
 		}
 	}
@@ -655,2 +673,22 @@
 	return pClass->GetNamespaceScopes().ToString() + "." + pClass->GetName() + "._Create";
 }
+
+bool BlittableType::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
+{
+	basicType.Resolve( resolver, resolveErrors );
+
+	if( this->pClass->IsNeedResolve() )
+	{
+		const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pClass );
+		if( pTempClass )
+		{
+			this->pClass = pTempClass;
+		}
+		else
+		{
+			resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
+		}
+	}
+
+	return true;
+}
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/TypeDef.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/TypeDef.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/TypeDef.cpp	(revision 640)
@@ -8,7 +8,7 @@
 }
 
-bool TypeDef::Resolve( const ObjectModule &resolver )
+bool TypeDef::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-	this->baseType.Resolve( resolver );
+	this->baseType.Resolve( resolver, resolveErrors );
 	return true;
 }
Index: trunk/ab5.0/abdev/ab_common/src/Lexical/Variable.cpp
===================================================================
--- trunk/ab5.0/abdev/ab_common/src/Lexical/Variable.cpp	(revision 639)
+++ trunk/ab5.0/abdev/ab_common/src/Lexical/Variable.cpp	(revision 640)
@@ -28,7 +28,7 @@
 }
 
-bool Variable::Resolve( const ObjectModule &resolver )
+bool Variable::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-	this->type.Resolve( resolver );
+	this->type.Resolve( resolver, resolveErrors );
 	return true;
 }
