Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision ef5b8288bd2be4816de42f8ea6a9b3d5e5971b31)
+++ src/ResolvExpr/Resolver.cc	(revision 8fd52e90372722cd58a940aabae4889d3072d17a)
@@ -562,7 +562,7 @@
 		// TODO: Replace *exception type with &exception type.
 		if ( throwStmt->get_expr() ) {
-			StructDecl * exception_decl = indexer.lookupMutableStruct( "__cfaabi_ehm__base_exception_t" );
+			const StructDecl * exception_decl = indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
 			assert( exception_decl );
-			Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
+			Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, const_cast<StructDecl *>(exception_decl) ) );
 			findSingleExpression( throwStmt->expr, exceptType, indexer );
 		}
Index: src/SymTab/Indexer.cc
===================================================================
--- src/SymTab/Indexer.cc	(revision ef5b8288bd2be4816de42f8ea6a9b3d5e5971b31)
+++ src/SymTab/Indexer.cc	(revision 8fd52e90372722cd58a940aabae4889d3072d17a)
@@ -122,6 +122,5 @@
 	}
 
-	const NamedTypeDecl * Indexer::lookupType( const std::string & id ) const { return lookupMutableType(id); }
-	NamedTypeDecl * Indexer::lookupMutableType( const std::string & id ) const {
+	const NamedTypeDecl * Indexer::lookupType( const std::string & id ) const {
 		++* stats().lookup_calls;
 		if ( ! typeTable ) return nullptr;
@@ -131,6 +130,5 @@
 	}
 
-	const StructDecl * Indexer::lookupStruct( const std::string & id ) const { return lookupMutableStruct(id); }
-	StructDecl * Indexer::lookupMutableStruct( const std::string & id ) const {
+	const StructDecl * Indexer::lookupStruct( const std::string & id ) const {
 		++* stats().lookup_calls;
 		if ( ! structTable ) return nullptr;
@@ -140,6 +138,5 @@
 	}
 
-	const EnumDecl * Indexer::lookupEnum( const std::string & id ) const { return lookupMutableEnum(id); }
-	EnumDecl * Indexer::lookupMutableEnum( const std::string & id ) const {
+	const EnumDecl * Indexer::lookupEnum( const std::string & id ) const {
 		++* stats().lookup_calls;
 		if ( ! enumTable ) return nullptr;
@@ -149,6 +146,5 @@
 	}
 
-	const UnionDecl * Indexer::lookupUnion( const std::string & id ) const { return lookupMutableUnion(id); }
-	UnionDecl * Indexer::lookupMutableUnion( const std::string & id ) const {
+	const UnionDecl * Indexer::lookupUnion( const std::string & id ) const {
 		++* stats().lookup_calls;
 		if ( ! unionTable ) return nullptr;
@@ -158,6 +154,5 @@
 	}
 
-	const TraitDecl * Indexer::lookupTrait( const std::string & id ) const { return lookupMutableTrait(id); }
-	TraitDecl * Indexer::lookupMutableTrait( const std::string & id ) const {
+	const TraitDecl * Indexer::lookupTrait( const std::string & id ) const {
 		++* stats().lookup_calls;
 		if ( ! traitTable ) return nullptr;
Index: src/SymTab/Indexer.h
===================================================================
--- src/SymTab/Indexer.h	(revision ef5b8288bd2be4816de42f8ea6a9b3d5e5971b31)
+++ src/SymTab/Indexer.h	(revision 8fd52e90372722cd58a940aabae4889d3072d17a)
@@ -64,17 +64,12 @@
 		/// Gets the top-most type declaration with the given ID
 		const NamedTypeDecl * lookupType( const std::string & id ) const;
-		NamedTypeDecl * lookupMutableType( const std::string & id ) const;
 		/// Gets the top-most struct declaration with the given ID
 		const StructDecl * lookupStruct( const std::string & id ) const;
-		StructDecl * lookupMutableStruct( const std::string & id ) const;
 		/// Gets the top-most enum declaration with the given ID
 		const EnumDecl * lookupEnum( const std::string & id ) const;
-		EnumDecl * lookupMutableEnum( const std::string & id ) const;
 		/// Gets the top-most union declaration with the given ID
 		const UnionDecl * lookupUnion( const std::string & id ) const;
-		UnionDecl * lookupMutableUnion( const std::string & id ) const;
 		/// Gets the top-most trait declaration with the given ID
 		const TraitDecl * lookupTrait( const std::string & id ) const;
-		TraitDecl * lookupMutableTrait( const std::string & id ) const;
 
 		/// Gets the type declaration with the given ID at global scope
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision ef5b8288bd2be4816de42f8ea6a9b3d5e5971b31)
+++ src/SymTab/Validate.cc	(revision 8fd52e90372722cd58a940aabae4889d3072d17a)
@@ -642,8 +642,8 @@
 
 	void LinkReferenceToTypes_old::postvisit( EnumInstType * enumInst ) {
-		EnumDecl * st = local_indexer->lookupMutableEnum( enumInst->name );
+		const EnumDecl * st = local_indexer->lookupEnum( enumInst->name );
 		// it's not a semantic error if the enum is not found, just an implicit forward declaration
 		if ( st ) {
-			enumInst->baseEnum = st;
+			enumInst->baseEnum = const_cast<EnumDecl *>(st); // Just linking in the node
 		} // if
 		if ( ! st || ! st->body ) {
@@ -662,8 +662,8 @@
 
 	void LinkReferenceToTypes_old::postvisit( StructInstType * structInst ) {
-		StructDecl * st = local_indexer->lookupMutableStruct( structInst->name );
+		const StructDecl * st = local_indexer->lookupStruct( structInst->name );
 		// it's not a semantic error if the struct is not found, just an implicit forward declaration
 		if ( st ) {
-			structInst->baseStruct = st;
+			structInst->baseStruct = const_cast<StructDecl *>(st); // Just linking in the node
 		} // if
 		if ( ! st || ! st->body ) {
@@ -675,8 +675,8 @@
 
 	void LinkReferenceToTypes_old::postvisit( UnionInstType * unionInst ) {
-		UnionDecl * un = local_indexer->lookupMutableUnion( unionInst->name );
+		const UnionDecl * un = local_indexer->lookupUnion( unionInst->name );
 		// it's not a semantic error if the union is not found, just an implicit forward declaration
 		if ( un ) {
-			unionInst->baseUnion = un;
+			unionInst->baseUnion = const_cast<UnionDecl *>(un); // Just linking in the node
 		} // if
 		if ( ! un || ! un->body ) {
@@ -762,5 +762,5 @@
 	void LinkReferenceToTypes_old::postvisit( TraitInstType * traitInst ) {
 		// handle other traits
-		TraitDecl * traitDecl = local_indexer->lookupMutableTrait( traitInst->name );
+		const TraitDecl * traitDecl = local_indexer->lookupTrait( traitInst->name );
 		if ( ! traitDecl ) {
 			SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
@@ -769,5 +769,5 @@
 			SemanticError( traitInst, "incorrect number of trait parameters: " );
 		} // if
-		traitInst->baseTrait = traitDecl;
+		traitInst->baseTrait = const_cast<TraitDecl *>(traitDecl); // Just linking in the node
 
 		// need to carry over the 'sized' status of each decl in the instance