Improvements outputting containers (#2815)

* #include an absolute path didn't work - because paths were taken to always be relative.

* Moved JSON source map writing logic to JSONSourceMapUtil.

* Use ArtifactHandler to read/write SourceMaps.
Use ObjectCastableAdapter to hold SourceMap
Only serialize SourceMap <-> JSON on demand.

* Make some types swappable.

* BoxValue impl.

* Added asBoxValue.

* Remove const get funcs.

* Fix typo in asBoxValue.

* Fix another typo in asBoxValue.

* Slightly simplify conversion to blob of SourceMap.

* WIP Api improvements around sourcemap/artifact/line-directive.

* Small fix for asBoxValue

* WIP outputting container with multiple artifacts.

* Added ArtifactContailerUtil::filter to produce an artifact hierarchy that only contains "signficant" and "blobable" artifacts.

* Make emitting IR disjoint to using a container.
Added -emit-ir option.
Simplfiy output.

* Fix typo in options parsing.

* Add a test that ouputs with an emit source map.

* Enable emitting our SlangIR module if no targets are specified.

* Fix issues constructing container.

* Extra checks getting obfuscated source map from a translation unit.

* Fix typo.

1 files changed, 81 insertions, 19 deletions

diff --git a/source/compiler-core/slang-artifact-container-util.cpp b/source/compiler-core/slang-artifact-container-util.cpp
index 6121df964..dfc385f9a 100644
--- a/source/compiler-core/slang-artifact-container-util.cpp
+++ b/source/compiler-core/slang-artifact-container-util.cpp
@@ -191,34 +191,24 @@ SlangResult ArtifactContainerWriter::getBaseName(IArtifact* artifact, String& ou
 
 SlangResult ArtifactContainerWriter::writeInDirectory(IArtifact* artifact, const String& baseName)
 {
-    
     // TODO(JS):
     // We could now output information about the desc/artifact, say as some json.
     // For now we assume the extension is good enough for most purposes.
     
+    // If it's an "arbitrary" container, we don't need to write it
+    if (artifact->getDesc().kind != ArtifactKind::Container)
     {
         // We can't write it without a blob
         ComPtr<ISlangBlob> blob;
-        const auto res = artifact->loadBlob(ArtifactKeep::No, blob.writeRef());
+        SLANG_RETURN_ON_FAIL(artifact->loadBlob(ArtifactKeep::No, blob.writeRef()));
 
-        if (SLANG_FAILED(res))
-        {
-            // If it failed and it's significant the whole write fails
-            if (ArtifactUtil::isSignificant(artifact))
-            {
-                return res;
-            }
-        }
-        
-        {
-            // Get the name of the artifact
-            StringBuilder artifactName;
-            SLANG_RETURN_ON_FAIL(ArtifactDescUtil::calcNameForDesc(artifact->getDesc(), baseName.getUnownedSlice(), artifactName));
+        // Get the name of the artifact
+        StringBuilder artifactName;
+        SLANG_RETURN_ON_FAIL(ArtifactDescUtil::calcNameForDesc(artifact->getDesc(), baseName.getUnownedSlice(), artifactName));
 
-            const auto combinedPath = Path::combine(m_entry.path, artifactName);
-            // Write out the blob
-            SLANG_RETURN_ON_FAIL(m_fileSystem->saveFileBlob(combinedPath.getBuffer(), blob));
-        }
+        const auto combinedPath = Path::combine(m_entry.path, artifactName);
+        // Write out the blob
+        SLANG_RETURN_ON_FAIL(m_fileSystem->saveFileBlob(combinedPath.getBuffer(), blob));
     }
 
     {
@@ -837,4 +827,76 @@ SlangResult ArtifactContainerUtil::readContainer(IArtifact* artifact, ComPtr<IAr
     return SLANG_OK;
 }
 
+/* static */SlangResult ArtifactContainerUtil::filter(IArtifact* artifact, ComPtr<IArtifact>& outArtifact)
+{
+    outArtifact.setNull();
+
+    // Copy the artifact
+    auto dstArtifact = ArtifactUtil::createArtifact(artifact->getDesc(), artifact->getName());
+
+    ComPtr<ISlangBlob> blob;
+
+    if (artifact->getDesc().kind != ArtifactKind::Container)
+    {
+        // We can't write it without a blob
+        const auto res = artifact->loadBlob(ArtifactKeep::No, blob.writeRef());
+
+        if (SLANG_FAILED(res))
+        {
+            // If it failed and it's significant the whole write fails
+            if (ArtifactUtil::isSignificant(artifact))
+            {
+                return res;
+            }
+        }
+        else
+        {
+            // Add the blob to the destination
+            dstArtifact->addRepresentationUnknown(blob);
+        }
+    }
+
+    // Copy the children after filtering
+    {
+        for (IArtifact* child : artifact->getChildren())
+        {
+            ComPtr<IArtifact> dstChild;
+            SLANG_RETURN_ON_FAIL(filter(child, dstChild));
+
+            if (dstChild)
+            {
+                dstArtifact->addChild(dstChild);
+            }
+        }
+    }
+
+    // Copy the associated after filtering
+    {
+        for (IArtifact* assoc : artifact->getAssociated())
+        {
+            ComPtr<IArtifact> dstAssoc;
+            SLANG_RETURN_ON_FAIL(filter(assoc, dstAssoc));
+
+            if (dstAssoc)
+            {
+                dstArtifact->addAssociated(dstAssoc);
+            }
+        }
+    }
+
+    // We only return the artifact if any of the following are true 
+    // 1) It has a blob representation
+    // 2) It contains children or associated artifacts
+
+    if (blob || 
+        dstArtifact->getChildren().count ||
+        dstArtifact->getAssociated().count)
+    {
+        outArtifact = dstArtifact;
+    }
+        
+    // If we return an artifact or not, this was successful
+    return SLANG_OK;
+}
+
 } // namespace Slang