zig

commit 85dd5746bdcbe655132df61ca4556c72711d12d7 (tree)
parent fe6cc0c3ba6eee1ad17c2b1816847fd9c324e01b
Author: Veikka Tuominen <git@vexu.eu>
Date:   Thu, 29 Oct 2020 15:19:02 +0200

Merge pull request #6678 from s-ol/doc-type-aware

generated docs improvements: add vector, fntype, anytype type-printing; bool, function value-printing
Diffstat:
M
lib/std/special/docs/main.js
 | 
35
++++++++++++++++++++++++++++++++++-
M
src/stage1/dump_analysis.cpp
 | 
34
++++++++++++++++++++++++++++++++++

2 files changed, 68 insertions(+), 1 deletion(-)
diff --git a/lib/std/special/docs/main.js b/lib/std/special/docs/main.js
@@ -540,7 +540,23 @@
                 return typeIndexName(value, wantHtml, wantLink);
             case typeKinds.Fn:
                 var fnObj = zigAnalysis.fns[value];
-                return typeIndexName(fnObj.type, wantHtml, wantLink);
+                var declPath = fnObj.decl && getCanonDeclPath(fnObj.decl);
+                var fnName = declPath ? declPath.declNames.join('.') : '(unknown)';
+
+                if (!wantHtml) {
+                    return fnName;
+                }
+
+                var str = '<span class="tok-fn">';
+                if (wantLink && declPath != null) {
+                  str += '<a href="' + navLink(declPath.pkgNames, declPath.declNames) + '">';
+                  str += escapeHtml(fnName);
+                  str += '</a>';
+                } else {
+                  str += escapeHtml(fnName);
+                }
+                str += '</span>';
+                return str;
             case typeKinds.Int:
                 return token(value, tokenKinds.Number, wantHtml);
             case typeKinds.Optional:
@@ -566,6 +582,13 @@
                 name += "]";
                 name += typeIndexName(typeObj.elem, wantHtml, wantSubLink, null);
                 return name;
+            case typeKinds.Vector:
+                var name = "Vector(";
+                name += token(typeObj.len, tokenKinds.Number, wantHtml);
+                name += ", ";
+                name += typeIndexName(typeObj.elem, wantHtml, wantSubLink, null);
+                name += ")";
+                return name;
             case typeKinds.Optional:
                 return "?" + typeIndexName(typeObj.child, wantHtml, wantSubLink, fnDecl, linkFnNameDecl);
             case typeKinds.Pointer:
@@ -721,6 +744,16 @@
                     payloadHtml += token('var', tokenKinds.Keyword, wantHtml);
                 }
                 return payloadHtml;
+            case typeKinds.Frame:
+                var fnObj = zigAnalysis.fns[typeObj.fn];
+                return '@Frame(' + getValueText(fnObj.type, typeObj.fn, wantHtml, wantSubLink) + ')';
+            case typeKinds.AnyFrame:
+                var name = token('anyframe', tokenKinds.Keyword, wantHtml);
+                if (typeObj.result) {
+                  name += "->";
+                  name += typeIndexName(typeObj.result, wantHtml, wantSubLink, null);
+                }
+                return name;
             default:
                 if (wantHtml) {
                     return escapeHtml(typeObj.name);
diff --git a/src/stage1/dump_analysis.cpp b/src/stage1/dump_analysis.cpp
@@ -352,6 +352,7 @@ struct AnalDumpCtx {
 
     ZigList<ZigFn *> fn_list;
     HashMap<const ZigFn *, uint32_t, fn_ptr_hash, fn_ptr_eql> fn_map;
+    HashMap<const ZigFn *, uint32_t, fn_ptr_hash, fn_ptr_eql> fn_decl_map;
 
     ZigList<AstNode *> node_list;
     HashMap<const AstNode *, uint32_t, node_ptr_hash, node_ptr_eql> node_map;
@@ -491,6 +492,7 @@ static uint32_t anal_dump_get_decl_id(AnalDumpCtx *ctx, Tld *tld) {
 
                 if (fn != nullptr) {
                     (void)anal_dump_get_type_id(ctx, fn->type_entry);
+                    ctx->fn_decl_map.put_unique(fn, decl_id);
                 }
                 break;
             }
@@ -1050,6 +1052,31 @@ static void anal_dump_type(AnalDumpCtx *ctx, ZigType *ty) {
             anal_dump_type_ref(ctx, ty->data.array.child_type);
             break;
         }
+        case ZigTypeIdVector: {
+            jw_object_field(jw, "len");
+            jw_int(jw, ty->data.vector.len);
+
+            jw_object_field(jw, "elem");
+            anal_dump_type_ref(ctx, ty->data.vector.elem_type);
+            break;
+        }
+        case ZigTypeIdAnyFrame: {
+            if (ty->data.any_frame.result_type != nullptr) {
+                jw_object_field(jw, "result");
+                anal_dump_type_ref(ctx, ty->data.any_frame.result_type);
+            }
+            break;
+        }
+        case ZigTypeIdFnFrame: {
+            jw_object_field(jw, "fnName");
+            jw_string(jw, buf_ptr(&ty->data.frame.fn->symbol_name));
+
+            jw_object_field(jw, "fn");
+            anal_dump_fn_ref(ctx, ty->data.frame.fn);
+            break;
+        }
+        case ZigTypeIdInvalid:
+            zig_unreachable();
         default:
             jw_object_field(jw, "name");
             jw_string(jw, buf_ptr(&ty->name));
@@ -1173,6 +1200,12 @@ static void anal_dump_fn(AnalDumpCtx *ctx, ZigFn *fn) {
     jw_object_field(jw, "type");
     anal_dump_type_ref(ctx, fn->type_entry);
 
+    auto entry = ctx->fn_decl_map.maybe_get(fn);
+    if (entry != nullptr) {
+      jw_object_field(jw, "decl");
+      jw_int(jw, entry->value);
+    }
+
     jw_end_object(jw);
 }
 
@@ -1187,6 +1220,7 @@ void zig_print_analysis_dump(CodeGen *g, FILE *f, const char *one_indent, const 
     ctx.decl_map.init(16);
     ctx.node_map.init(16);
     ctx.fn_map.init(16);
+    ctx.fn_decl_map.init(16);
     ctx.err_map.init(16);
 
     jw_begin_object(jw);