semantic::NameResolver Class Reference

Inheritance diagram for semantic::NameResolver:

Classes
struct	Pkg
	Represents a tree of packages. The leaf nodes are declarations. More...

Public Types
using	ConstImport = std::variant< ast::Decl const *, Pkg const * >
using	ConstImportOpt = std::optional< ConstImport >

Public Member Functions
	NameResolver (BumpAllocator &alloc, diagnostics::DiagnosticEngine &diag)
	Construct a new Name Resolver object. More...
void	Init (ast::LinkingUnit *lu, ast::Semantic *sema)
	Initializes a new Name Resolver object given the entire linking unit (and all its symbols). After this, call Resolve() to resolve all types in the linking unit. More...
void	ResolveType (ast::UnresolvedType *type) override
	Resolves the type in-place (does not return anything) More...
ConstImportOpt	GetImport (ast::CompilationUnit const *cu, std::string_view name, std::pmr::memory_resource *r=std::pmr::get_default_resource()) const
	Get an import object from the import table of the given compilation unit. This object can either be a package or a declaration. More...
auto	GetJavaLang () const
	Get a struct with all the java.lang.* classes and interfaces. Also includes java.io.Serializable for some reason. More...
auto	GetArrayPrototype () const
	Get the Array Prototype object. This is a decl representing the prototype of the array class.
void	BeginContext (ast::CompilationUnit *cu)
	Called to begin the resolution of a compilation unit. This will build the import table (and any other data structures) to help resolve types within the compilation unit. More...
void	EndContext ()
	Called to end the resolution of a compilation unit. This will clear the current compilation unit being resolved.
void	dump () const
	Dumps the symbol and import tables to the output stream.
void	dumpImports (ast::CompilationUnit const *cu) const
	Dumps the import table to the output stream.
void	dumpImports () const
	Dumps the import table to the output stream.

Detailed Description

Definition at line 29 of file NameResolver.h.

Constructor & Destructor Documentation

NameResolver()

semantic::NameResolver::NameResolver ( BumpAllocator &  alloc, diagnostics::DiagnosticEngine &  diag  )

inline

Construct a new Name Resolver object.

Parameters

alloc	The bump allocator to use for all allocations.
diag	The diagnostic engine to use for all diagnostics.

Definition at line 81 of file NameResolver.h.

         : alloc{alloc}, diag{diag}, lu_{nullptr}, importsMap_{alloc} {}

Member Function Documentation

BeginContext()

void semantic::NameResolver::BeginContext

(

ast::CompilationUnit *

cu

)

Called to begin the resolution of a compilation unit. This will build the import table (and any other data structures) to help resolve types within the compilation unit.

Parameters

cu	The compilation unit to begin resolution for.

Definition at line 173 of file NameResolver.cc.

                                                      {
   // Set the current compilation unit and clear the imports map
   auto& importsMap = importsMap_[cu];
   currentCU_ = cu;
   // Package should be an unresolved type
   auto curPkg = cast<UnresolvedType>(cu->package());
 
   // We can populate the imports map by order of shadowing cf. JLS 6.3.1.
   //   1. Package declarations, does not shadow anything.
   //   2. Import-on-demand declarations, never causes any declaration to be
   //      shadowed (even with other IOD), but maybe shadow other packages.
   //   3. All declarations in the same package (different CUs).
   //   4. Single-type-import declarations, shadows any other decl in all CUs
   //      under the same package. It also shadows any import-on-demand decls.
   //   4. All declarations in the current CU.
   // We should also note the scope of types under the same package declarations
   // cf. JLS 6.3 is visible across all CUs in the same package.
 
   // 1. Import-on-demand declarations. Populate this first so we can check
   //    if two import-on-demand declarations shadow each other.
   for(auto const& imp : cu->imports()) {
      if(!imp.isOnDemand) continue;
      // First, resolve the subpackage subtree from the symbol table.
      auto subPkg = resolveImport(static_cast<UnresolvedType const*>(imp.type));
      // No value means an error has been reported, skip this import.
      if(!subPkg) continue;
      if(!std::holds_alternative<Pkg*>(subPkg.value())) {
         diag.ReportError(imp.location())
               << "failed to resolve import-on-demand as subpackage is a "
                  "declaration: \""
               << imp.simpleName() << "\"";
         continue;
      }
      // Grab the package as a Pkg*.
      auto pkg = std::get<Pkg*>(subPkg.value());
      // Second, add all the Decl from the subpackage to the imports map.
      // We only add declarations, not subpackages. cf. JLS 7.5:
      //
      //    > A type-import-on-demand declaration (§7.5.2) imports all the
      //    > accessible types of a named type or package as needed.
      //
      for(auto& kv : pkg->children) {
         if(!std::holds_alternative<Decl*>(kv.second)) continue;
         auto decl = std::get<Decl*>(kv.second);
         if(importsMap.find(kv.first) != importsMap.end()) {
            auto imported = importsMap[kv.first];
            if(std::holds_alternative<Decl*>(imported) &&
               std::get<Decl*>(imported) == decl)
               continue; // Same declaration, no error
            // FIXME(kevin): The import-on-demand shadows another
            // import-on-demand, so we mark the declaration as a null pointer.
            importsMap[kv.first] = static_cast<Decl*>(nullptr);
            continue;
         }
         importsMap[kv.first] = Pkg::Child{decl};
      }
   }
   // 2. Package declarations. We can ignore any duplicate names as they are
   //    shadowed by the import-on-demand declarations.
   for(auto& kv : rootPkg_->children) {
      if(!std::holds_alternative<Pkg*>(kv.second))
         continue; // We only care about subpackages
      if(importsMap.find(kv.first) != importsMap.end())
         continue; // This package is shadowed by an import-on-demand
      importsMap[kv.first] = Pkg::Child{std::get<Pkg*>(kv.second)};
   }
   // 3. All declarations in the same package (different CUs). We can shadow
   //    any declarations already existing.
   {
      auto curTree = resolveImport(curPkg);
      assert(curTree && "Current package should exist!");
      assert(std::holds_alternative<Pkg*>(curTree.value()));
      for(auto& kv : std::get<Pkg*>(curTree.value())->children)
         if(std::holds_alternative<Decl*>(kv.second))
            importsMap[kv.first] = Pkg::Child{std::get<Decl*>(kv.second)};
   }
   // 4. Single-type-import declarations. This may also shadow anything existing.
   for(auto const& imp : cu->imports()) {
      if(imp.isOnDemand) continue;
      // First, resolve the subpackage subtree from the symbol table.
      auto subPkg = resolveImport(static_cast<UnresolvedType const*>(imp.type));
      if(!subPkg) continue;
      if(!std::holds_alternative<Decl*>(subPkg.value())) {
         diag.ReportError(imp.location())
               << "failed to resolve single-type-import as a declaration: \""
               << imp.simpleName() << "\"";
         continue;
      }
      // Second, add the Decl from the subpackage to the imports map.
      auto decl = std::get<Decl*>(subPkg.value());
      auto cuDecl = cu->bodyAsDecl();
      // If the single-type-import name is the same as the class name, then it
      // shadows the class name. This is an error.
      if((decl->name() == cuDecl->name()) && (decl != cuDecl)) {
         diag.ReportError(cu->location()) << "single-type-import is the same "
                                             "as the class/interface name: "
                                          << decl->name();
         continue;
      }
      std::pmr::string name{imp.simpleName().data(), alloc};
      importsMap[name] = decl;
   }
   // 5. All declarations in the current CU. This may also shadow anything.
   if(cu->body())
      importsMap[cu->bodyAsDecl()->name().data()] = cu->mut_bodyAsDecl();
}

GetImport()

NameResolver::ConstImportOpt semantic::NameResolver::GetImport	(	ast::CompilationUnit const *	cu,
		std::string_view	name,
		std::pmr::memory_resource *	r = std::pmr::get_default_resource()
	)		const

Get an import object from the import table of the given compilation unit. This object can either be a package or a declaration.

Parameters

cu	The compilation unit to get the import from.
name	The name of the import to get.
r	An optional memory resource to use for allocations.

Returns

ConstImport Returns nullopt if the import is not found. Otheriwse, returns the import object from the import table. Note, the package object will never be null. However, a declaration object can be null if the import-on-demand results in an unresolvable declaration.

Definition at line 437 of file NameResolver.cc.

                                      {
   // Grab the import map
   auto it = importsMap_.find(cu);
   assert(it != importsMap_.end() && "Compilation unit not found in import map");
   auto const& importsMap = it->second;
 
   // Grab the import from the map
   BumpAllocator alloc1{r};
   std::pmr::string str{name, alloc1};
   auto it2 = importsMap.find(str);
 
   // If the import is not found, then we can return a null optional
   if(it2 == importsMap.end()) return std::nullopt;
 
   // If the import is found, then we can return it
   if(std::holds_alternative<Decl*>(it2->second)) {
      return static_cast<Decl const*>(std::get<Decl*>(it2->second));
   } else {
      return static_cast<Pkg const*>(std::get<Pkg*>(it2->second));
   }
}

GetJavaLang()

auto semantic::NameResolver::GetJavaLang ( ) const

inline

Get a struct with all the java.lang.* classes and interfaces. Also includes java.io.Serializable for some reason.

Returns

auto An anonymous struct with all the java.lang.* types.

Definition at line 126 of file NameResolver.h.

{ return java_lang_; }

Init()

void semantic::NameResolver::Init ( ast::LinkingUnit *  lu, ast::Semantic *  sema  )

inline

Initializes a new Name Resolver object given the entire linking unit (and all its symbols). After this, call Resolve() to resolve all types in the linking unit.

Parameters

lu	The linking unit to resolve.

Definition at line 91 of file NameResolver.h.

                                                    {
      lu_ = lu;
      sema_ = sema;
      buildSymbolTable();
      populateJavaLangCache();
   }

ResolveType()

void semantic::NameResolver::ResolveType ( ast::UnresolvedType *  type )

overridevirtual

Resolves the type in-place (does not return anything)

Parameters

type	The unresolved type to resolve.

Implements ast::TypeResolver.

Definition at line 311 of file NameResolver.cc.

                                                 {
   assert(ty && "Type should not be null");
   assert(!ty->isResolved() && "Type should not be resolved");
   if(ty->parts().empty()) return;
   Pkg::Child subTy;
   auto it = ty->parts().begin();
   // Resolve the first level of the type against importMaps_
   auto& importsMap = importsMap_[currentCU_];
   if(auto it2 = importsMap.find(*it); it2 != importsMap.end()) {
      subTy = it2->second;
   } else {
      diag.ReportError(ty->location())
            << "failed to resolve type as subpackage does not exist: \"" << *it
            << "\"";
      return;
   }
   // Now resolve the remainder of the type against subTy
   it = std::next(it);
   for(; it != ty->parts().end(); it++) {
      // If the subpackage is a declaration, then the import is invalid.
      if(std::holds_alternative<Decl*>(subTy)) {
         diag.ReportError(ty->location())
               << "failed to resolve type as subpackage is a declaration: \""
               << *it << "\"";
         return;
      }
      // Now that we know it's not a decl, get it as a package.
      auto pkg = std::get<Pkg*>(subTy);
      // If the subpackage does not exist, then the import is invalid.
      if(pkg->children.find(*it) == pkg->children.end()) {
         diag.ReportError(ty->location())
               << "failed to resolve type as subpackage does not exist: \"" << *it
               << "\"";
         return;
      }
      // Get the next subpackage.
      subTy = pkg->children[*it];
   }
   // The final type should be a declaration.
   if(!std::holds_alternative<Decl*>(subTy)) {
      diag.ReportError(ty->location())
            << "failed to resolve type, is not a declaration: \"" << ty->toString()
            << "\"";
      return;
   }
   // If subTy is nullptr, then an ambiguous import-on-demand has shadowed the
   // declaration. This is an error.
   if(!std::get<Decl*>(subTy)) {
      ty->invalidate();
      diag.ReportError(ty->location())
            << "failed to resolve type, ambiguous import-on-demand: \""
            << ty->toString() << "\"";
      return;
   }
   // Now we can create a reference type to the declaration.
   ty->resolveInternal(std::get<Decl*>(subTy));
   // After, the type should be resolved
   assert(ty->isResolved() && "Type should be resolved");
}

References ast::ReferenceType::resolveInternal(), and ast::UnresolvedType::toString().

---

The documentation for this class was generated from the following files:

• include/semantic/NameResolver.h
• lib/semantic/NameResolver.cc