Move CppParser method definitions out of the headers and into the source file.

This is a workaround for missing symbols when P/Invoking on the Mac for instance. There should be a working "-fkeep-inline-functions" switch available in Clang but upon reading the source code, it does not do anything besides consuming the option (not even a warning!).

src/CppParser/AST.cpp

@@ -29,6 +29,48 @@ static std::vector<T> split(const T & str, const T & delimiters) {
 
 namespace CppSharp { namespace CppParser { namespace AST {
 
+Type::Type(TypeKind kind) : Kind(kind) {}
+QualifiedType::QualifiedType() : Type(0) {}
+
+TagType::TagType() : Type(TypeKind::Tag) {}
+
+ArrayType::ArrayType() : Type(TypeKind::Array) {}
+
+FunctionType::FunctionType() : Type(TypeKind::Function) {}
+
+PointerType::PointerType() : Type(TypeKind::Pointer) {}
+
+MemberPointerType::MemberPointerType() : Type(TypeKind::MemberPointer) {}
+
+TypedefType::TypedefType() : Type(TypeKind::Typedef), Declaration(0) {}
+
+AttributedType::AttributedType() : Type(TypeKind::Attributed) {}
+
+DecayedType::DecayedType() : Type(TypeKind::Decayed) {}
+
+TemplateArgument::TemplateArgument() : Declaration(0) {}
+
+TemplateSpecializationType::TemplateSpecializationType()
+    : Type(TypeKind::TemplateSpecialization), Template(0), Desugared(0) {}
+
+TemplateParameterType::TemplateParameterType() : Type(TypeKind::TemplateParameter) {}
+
+TemplateParameterSubstitutionType::TemplateParameterSubstitutionType()
+    : Type(TypeKind::TemplateParameterSubstitution) {}
+
+InjectedClassNameType::InjectedClassNameType() : Type(TypeKind::InjectedClassName),
+    Class(0) {}
+
+DependentNameType::DependentNameType() : Type(TypeKind::DependentName) {}
+
+BuiltinType::BuiltinType() : CppSharp::CppParser::AST::Type(TypeKind::Builtin) {}
+
+RawComment::RawComment() : FullComment(0) {}
+
+VTableComponent::VTableComponent() : Offset(0), Declaration(0) {}
+
+ClassLayout::ClassLayout() : ABI(CppAbi::Itanium) {}
+
 Declaration::Declaration(DeclarationKind kind)
     : Kind(kind)
     , Access(AccessSpecifier::Public)
@@ -42,6 +84,9 @@ Declaration::Declaration(DeclarationKind kind)
 {
 }
 
+DeclarationContext::DeclarationContext()
+    : Declaration(DeclarationKind::DeclarationContext) {}
+
 Declaration* DeclarationContext::FindAnonymous(uint64_t key)
 {
     auto it = Anonymous.find(key);
@@ -266,6 +311,56 @@ TypedefDecl* DeclarationContext::FindTypedef(const std::string& Name, bool Creat
     return tdef;
 }
 
+TypedefDecl::TypedefDecl() : Declaration(DeclarationKind::Typedef) {}
+
+Parameter::Parameter() : Declaration(DeclarationKind::Parameter),
+    IsIndirect(false), HasDefaultValue(false) {}
+
+Function::Function() : Declaration(DeclarationKind::Function),
+    IsReturnIndirect(false) {}
+
+Method::Method() : IsDefaultConstructor(false), IsCopyConstructor(false),
+    IsMoveConstructor(false) { Kind = DeclarationKind::Method; }
+
+Enumeration::Enumeration() : Declaration(DeclarationKind::Enumeration) {}
+
+Enumeration::Item::Item() : Declaration(DeclarationKind::EnumerationItem) {}
+
+Variable::Variable() : Declaration(DeclarationKind::Variable) {}
+
+BaseClassSpecifier::BaseClassSpecifier() : Type(0) {}
+
+Field::Field() : Declaration(DeclarationKind::Field), Class(0) {}
+
+AccessSpecifierDecl::AccessSpecifierDecl()
+    : Declaration(DeclarationKind::AccessSpecifier) {}
+
+Class::Class() { Kind = DeclarationKind::Class; }
+
+Template::Template() : Declaration(DeclarationKind::Template) {}
+
+ClassTemplate::ClassTemplate() { Kind = DeclarationKind::ClassTemplate; }
+
+ClassTemplateSpecialization::ClassTemplateSpecialization()
+    { Kind = DeclarationKind::ClassTemplateSpecialization; }
+
+ClassTemplatePartialSpecialization::ClassTemplatePartialSpecialization()
+    { Kind = DeclarationKind::ClassTemplatePartialSpecialization; }
+
+FunctionTemplate::FunctionTemplate() { Kind = DeclarationKind::FunctionTemplate; }
+
+Namespace::Namespace() { Kind = DeclarationKind::Namespace; }
+
+PreprocessedEntity::PreprocessedEntity()
+    : Declaration(DeclarationKind::PreprocessedEntity),
+      Location(MacroLocation::Unknown) {}
+
+MacroDefinition::MacroDefinition() { Kind = DeclarationKind::MacroDefinition; }
+
+MacroExpansion::MacroExpansion() { Kind = DeclarationKind::MacroExpansion; }
+
+TranslationUnit::TranslationUnit() { Kind = DeclarationKind::TranslationUnit; }
+
 ClassTemplateSpecialization* ClassTemplate::FindSpecialization(void* ptr)
 {
     return 0;

src/CppParser/AST.h

@@ -58,11 +58,11 @@ enum struct TypeKind
 };
 
 #define DECLARE_TYPE_KIND(kind) \
-    kind##Type() : CppSharp::CppParser::AST::Type(TypeKind::kind) {}
+    kind##Type();
 
 struct CS_API Type
 {
-    Type(TypeKind kind) : Kind(kind) {}
+    Type(TypeKind kind);
     TypeKind Kind;
     bool IsDependent;
 };
@@ -76,7 +76,7 @@ struct CS_API TypeQualifiers
 
 struct CS_API QualifiedType
 {
-    QualifiedType() : Type(0) {}
+    QualifiedType();
     CppSharp::CppParser::AST::Type* Type;
     TypeQualifiers Qualifiers;
 };
@@ -150,7 +150,7 @@ struct TypedefDecl;
 
 struct CS_API TypedefType : public Type
 {
-    TypedefType() : Type(TypeKind::Typedef), Declaration(0) {}
+    TypedefType();
     TypedefDecl* Declaration;
 };
 
@@ -171,7 +171,7 @@ struct CS_API DecayedType : public Type
 
 struct CS_API TemplateArgument
 {
-    TemplateArgument() : Declaration(0) {}
+    TemplateArgument();
 
     enum struct ArgumentKind
     {
@@ -195,8 +195,7 @@ struct Template;
 
 struct CS_API TemplateSpecializationType : public Type
 {
-    TemplateSpecializationType() : Type(TypeKind::TemplateSpecialization),
+    TemplateSpecializationType();
-        Template(0), Desugared(0) {}
     VECTOR(TemplateArgument, Arguments)
     CppSharp::CppParser::AST::Template* Template;
     Type* Desugared;
@@ -228,8 +227,7 @@ struct Class;
 
 struct CS_API InjectedClassNameType : public Type
 {
-    InjectedClassNameType() : Type(TypeKind::InjectedClassName),
+    InjectedClassNameType();
-        Class(0) {}
     TemplateSpecializationType TemplateSpecialization;
     CppSharp::CppParser::AST::Class* Class;
 };
@@ -284,6 +282,7 @@ struct FullComment;
 
 struct CS_API RawComment
 {
+    RawComment();
     RawCommentKind Kind;
     STRING(Text)
     STRING(BriefText)
@@ -306,7 +305,7 @@ enum struct VTableComponentKind
 
 struct CS_API VTableComponent
 {
-    VTableComponent() : Offset(0), Declaration(0) {}
+    VTableComponent();
     VTableComponentKind Kind;
     unsigned Offset;
     CppSharp::CppParser::AST::Declaration* Declaration;
@@ -334,7 +333,7 @@ enum struct CppAbi
 
 struct CS_API ClassLayout
 {
-    ClassLayout() : ABI(CppAbi::Itanium) {}
+    ClassLayout();
     CppAbi ABI;
     VECTOR(VFTableInfo, VFTables)
     VTableLayout Layout;
@@ -393,7 +392,7 @@ enum struct DeclarationKind
 };
 
 #define DECLARE_DECL_KIND(klass, kind) \
-    klass() : Declaration(DeclarationKind::kind) {}
+    klass();
 
 struct CS_API Declaration
 {
@@ -465,8 +464,7 @@ struct CS_API TypedefDecl : public Declaration
 
 struct CS_API Parameter : public Declaration
 {
-    Parameter() : Declaration(DeclarationKind::Parameter),
+    Parameter();
-        IsIndirect(false), HasDefaultValue(false) {}
 
     CppSharp::CppParser::AST::QualifiedType QualifiedType;
     bool IsIndirect;
@@ -533,8 +531,7 @@ enum struct CXXOperatorKind
 
 struct CS_API Function : public Declaration
 {
-    Function() : Declaration(DeclarationKind::Function),
+    Function();
-        IsReturnIndirect(false) {}
 
     QualifiedType ReturnType;
     bool IsReturnIndirect;
@@ -554,8 +551,7 @@ struct AccessSpecifierDecl;
 
 struct CS_API Method : public Function
 {
-    Method() : IsDefaultConstructor(false), IsCopyConstructor(false),
+    Method();
-        IsMoveConstructor(false) { Kind = DeclarationKind::Method; }
 
     AccessSpecifierDecl* AccessDecl;
 
@@ -608,6 +604,7 @@ struct CS_API Variable : public Declaration
 
 struct CS_API BaseClassSpecifier
 {
+    BaseClassSpecifier();
     AccessSpecifier Access;
     bool IsVirtual;
     CppSharp::CppParser::AST::Type* Type;
@@ -631,7 +628,7 @@ struct CS_API AccessSpecifierDecl : public Declaration
 
 struct CS_API Class : public DeclarationContext
 {
-    Class() { Kind = DeclarationKind::Class; }
+    Class();
 
     VECTOR(BaseClassSpecifier*, Bases)
     VECTOR(Field*, Fields)
@@ -662,7 +659,7 @@ struct ClassTemplatePartialSpecialization;
 
 struct CS_API ClassTemplate : public Template
 {
-    ClassTemplate() { Kind = DeclarationKind::ClassTemplate; }
+    ClassTemplate();
     VECTOR(ClassTemplateSpecialization*, Specializations)
     ClassTemplateSpecialization* FindSpecialization(void* ptr);
     ClassTemplateSpecialization* FindSpecialization(TemplateSpecializationType type);
@@ -681,8 +678,7 @@ enum struct TemplateSpecializationKind
 
 struct CS_API ClassTemplateSpecialization : public Class
 {
-    ClassTemplateSpecialization() {
+    ClassTemplateSpecialization();
-        Kind = DeclarationKind::ClassTemplateSpecialization; }
     ClassTemplate* TemplatedDecl;
     VECTOR(TemplateArgument, Arguments)
     TemplateSpecializationKind SpecializationKind;
@@ -690,44 +686,41 @@ struct CS_API ClassTemplateSpecialization : public Class
 
 struct CS_API ClassTemplatePartialSpecialization : public ClassTemplateSpecialization
 {
-    ClassTemplatePartialSpecialization() { Kind =
+    ClassTemplatePartialSpecialization();
-        DeclarationKind::ClassTemplatePartialSpecialization; }
 };
 
 struct CS_API FunctionTemplate : public Template
 {
-    FunctionTemplate() { Kind = DeclarationKind::FunctionTemplate; }
+    FunctionTemplate();
 };
 
 struct CS_API Namespace : public DeclarationContext
 {
-    Namespace() { Kind = DeclarationKind::Namespace; }
+    Namespace();
 };
 
 struct CS_API PreprocessedEntity : public Declaration
 {
-    PreprocessedEntity() : Declaration(DeclarationKind::PreprocessedEntity),
+    PreprocessedEntity();
-        Location(MacroLocation::Unknown) {}
-
     MacroLocation Location;
 };
 
 struct CS_API MacroDefinition : public PreprocessedEntity
 {
-    MacroDefinition() { Kind = DeclarationKind::MacroDefinition; }
+    MacroDefinition();
     STRING(Expression)
 };
 
 struct CS_API MacroExpansion : public PreprocessedEntity
 {
-    MacroExpansion() { Kind = DeclarationKind::MacroExpansion; }
+    MacroExpansion();
     STRING(Text)
     MacroDefinition* Definition;
 };
 
 struct CS_API TranslationUnit : public Namespace
 {
-    TranslationUnit() { Kind = DeclarationKind::TranslationUnit; }
+    TranslationUnit();
     STRING(FileName)
     bool IsSystemHeader;
     VECTOR(MacroDefinition*, Macros)

src/CppParser/CppParser.cpp

@@ -0,0 +1,29 @@
+/************************************************************************
+*
+* CppSharp
+* Licensed under the MIT license.
+*
+************************************************************************/
+
+#include "CppParser.h"
+
+namespace CppSharp { namespace CppParser {
+
+ParserOptions::ParserOptions()
+    : ASTContext(0)
+    , ToolSetToUse(0)
+    , Abi(CppAbi::Itanium)
+    , NoStandardIncludes(false)
+    , NoBuiltinIncludes(false)
+    , MicrosoftMode(false)
+    , Verbose(false)
+{
+}
+
+ParserResult::ParserResult()
+    : ASTContext(0)
+    , Library(0)
+{
+}
+
+} }

src/CppParser/CppParser.h

@@ -32,16 +32,7 @@ using namespace CppSharp::CppParser::AST;
 
 struct CS_API ParserOptions
 {
-    ParserOptions()
+    ParserOptions();
-        : ASTContext(0)
-        , ToolSetToUse(0)
-        , Abi(CppAbi::Itanium)
-        , NoStandardIncludes(false)
-        , NoBuiltinIncludes(false)
-        , MicrosoftMode(false)
-        , Verbose(false)
-    {
-    }
 
     // C/C++ header file name.
     STRING_OPTIONS(FileName)
@@ -91,6 +82,8 @@ enum struct ParserResultKind
 
 struct CS_API ParserResult
 {
+    ParserResult();
+
     ParserResultKind Kind;
     VECTOR_OPTIONS(ParserDiagnostic, Diagnostics)