rename attributes & constructors!!!

Author: jaredly

example-project/src/Hello.re

@@ -1,19 +1,20 @@
-let someLongName = 10;
+/* let someLongName = 10;
 
 let otherLongName = "string";
 
-string_of_bool;
+string_of_bool; */
 
 module Something = {
   open Other;
 
-  let m = {name: "Me", age: 0};
-  let animal = Dog(10);
-  let other = Dog(2);
+  let m = {firstName: "Me", age: 0};
+  let animal = Wolf(10);
+  let other = Wolf(2);
   let me = Cat("Hie");
   let x = something + 10;
 };
 
+/*
 open Something;
 
 let y = x + 10;
@@ -116,4 +117,5 @@ switch (y) {
 
 /* let x = [%raw " hello"]; */
 
-let awesome = "hello";
+let awesome = "hello";
+*/

example-project/src/Other.re

@@ -1,16 +1,16 @@
 
-let later = 10;
+/* let later = 10; */
 
 /* Ok testing things */
 
 let something = 10;
 
-type person = {name: string, age: int};
+type person = {firstName: string, age: int};
 
-type animals = Dog(int) | Cat(string) | Mouse;
+type animals = Wolf(int) | Cat(string) | Mouse;
 
-let m = Dog(1);
+let m = Wolf(1);
 
-let z = {name: "hi", age: 20};
+let z = {firstName: "hi", age: 20};
 
-let e = z.name;
+/* let e = z.name; */

src/Definition.re

@@ -56,10 +56,10 @@ type anOpen = {
 type moduleData = {
   mutable toplevelDocs: option(string),
   stamps: Hashtbl.t(int, (string, Location.t, item, option(string), ((int, int), (int, int)))),
-  /* TODO track constructor names, and record attribute names */
   internalReferences: Hashtbl.t(int, list(Location.t)),
   externalReferences: Hashtbl.t(string, list((list(string), Location.t, option(string)))),
   exported: Hashtbl.t(string, int),
+  mutable exportedSuffixes: list((int, string, string)),
   mutable topLevel: list((string, int)),
   mutable locations: list((Location.t, Types.type_expr, definition)),
   mutable allOpens: list(anOpen)
@@ -391,11 +391,14 @@ let openReferencesAtPos = ({allOpens} as data, pos) => {
 };
 
 let isStampExported = (needle, data) =>
-  Hashtbl.fold(
-    (name, stamp, found) => found != None ? found : stamp == needle ? Some(name) : None,
+  switch (Hashtbl.fold(
+    (name, stamp, found) => found != None ? found : stamp == needle ? Some((name, None)) : None,
     data.exported,
     None
-  );
+  )) {
+    | Some(m) => Some(m)
+    | None => data.exportedSuffixes |> Utils.find(((suffixStamp, mainName, suffixName)) => suffixStamp == needle ? Some((mainName, Some(suffixName))) : None)
+  };
 
 let highlightsForStamp = (stamp, data) =>
   maybeFound(Hashtbl.find(data.stamps), stamp)
@@ -437,18 +440,6 @@ let rec stampAtPath = (path, data, suffix) =>
   | _ => None
   };
 
-/* let suffixAtPath = (path, suffix, data) => {
-  stampAtPath(path, data) |?> stamp => switch stamp {
-    | `Global(name, children) => Some(`Global(name, children, suffix))
-    | `Local(stamp) => (maybeFound(Hashtbl.find(Collector.data.stamps), stamp) |?> ((name, loc, item, docs, range)) => {
-      switch item {
-        | Type(t) => getSuffix(t, suffix) |?>> ((loc, stamp)) => `Local(stamp)
-        | _ => None
-      }
-    })
-  }
-}; */
-
 let stampAtPos = (pos, data) =>
   locationAtPos(pos, data)
   |?> (
@@ -702,19 +693,24 @@ module Get = {
 
                   switch (typ_type.type_kind) {
                     | Types.Type_record(labels, _) => {
-                      labels |> List.iter(({Types.ld_id: {stamp, name: lname}, ld_type, ld_loc}) => {
+                      labels |> List.iter(({Types.ld_id: {stamp: lstamp, name: lname}, ld_type, ld_loc}) => {
                         let shortLoc = Utils.clampLocation(ld_loc, String.length(lname));
-                        addStamp(stamp, lname, shortLoc, Attribute(ld_type, name, typ_type), docs);
-                        addLocation(shortLoc, {Types.desc: Types.Tnil, level: 0, id: 0}, IsDefinition(stamp));
+                        addStamp(lstamp, lname, shortLoc, Attribute(ld_type, name, typ_type), docs);
+                        if (maybeFound(Hashtbl.find(Collector.data.exported), name) == Some(stamp)) {
+                          Collector.data.exportedSuffixes = [(lstamp, name, lname), ...Collector.data.exportedSuffixes];
+                        };
+                        addLocation(shortLoc, {Types.desc: Types.Tnil, level: 0, id: 0}, IsDefinition(lstamp));
                       })
                     }
                     | Types.Type_variant(constructors) => {
-                      constructors |> List.iter(({Types.cd_id: {stamp, name: cname}, cd_loc} as cd) => {
+                      constructors |> List.iter(({Types.cd_id: {stamp: cstamp, name: cname}, cd_loc} as cd) => {
                         let shortLoc = Utils.clampLocation(cd_loc, String.length(cname));
-                        addStamp(stamp, cname, shortLoc, Constructor(cd, name, typ_type), docs);
-                        addLocation(shortLoc, {Types.desc: Types.Tnil, level: 0, id: 0}, IsDefinition(stamp));
+                        addStamp(cstamp, cname, shortLoc, Constructor(cd, name, typ_type), docs);
+                        addLocation(shortLoc, {Types.desc: Types.Tnil, level: 0, id: 0}, IsDefinition(cstamp));
+                        if (maybeFound(Hashtbl.find(Collector.data.exported), name) == Some(stamp)) {
+                          Collector.data.exportedSuffixes = [(cstamp, name, cname), ...Collector.data.exportedSuffixes];
+                        };
                       })
-
                     }
                     | _ => ()
                   }
@@ -884,6 +880,7 @@ module Get = {
       stamps: Hashtbl.create(100),
       internalReferences: Hashtbl.create(100),
       externalReferences: Hashtbl.create(100),
+      exportedSuffixes: [],
       exported: Hashtbl.create(10),
       allOpens: [],
       topLevel: [],

src/State.re

@@ -134,12 +134,10 @@ let resolveDefinition = (uri, defn, state) =>
   | `Local(_, loc, item, docs, _) => Some((loc, docs, uri))
   | `Global(top, children, suffix) =>
     {
-      Log.log("Resolving global " ++ top);
       switch (
         maybeFound(List.assoc(top), state.localModules)
         |?> (
           ((cmt, src)) => {
-            Log.log("Found it " ++ src);
             let uri = "file://" ++ src;
             maybeFound(Hashtbl.find(state.compiledDocuments), uri)
             |?> AsYouType.getResult
@@ -184,17 +182,17 @@ let referencesForPos = (uri, pos, data, state) => {
   /* TODO handle cross-file stamps, e.g. the location isn't a stamp */
   Definition.stampAtPos(pos, data)
   |?> stamp => {
-    let externals = (Definition.isStampExported(stamp, data) |?>> exportedName => {
+    let externals = (Definition.isStampExported(stamp, data) |?>> ((exportedName, suffixName)) => {
       let thisModName = FindFiles.getName(uri);
       optMap(((modname, (cmt, src))) => {
         if (modname == thisModName) {
           None
         } else {
           getDefinitionData("file://" ++ src, state) |?> data => {
             Definition.maybeFound(Hashtbl.find(data.Definition.externalReferences), thisModName) |?> uses => {
-              let realUses = Utils.filterMap(((path, loc, suffix/* TODO */)) => {
-                if (path == [exportedName]) {
-                  Some((`Read, Utils.endOfLocation(loc, String.length(exportedName))))
+              let realUses = Utils.filterMap(((path, loc, suffix)) => {
+                if (path == [exportedName] && suffix == suffixName) {
+                  Some((`Read, Utils.endOfLocation(loc, String.length(suffixName |? exportedName))))
                 } else {
                   None
                 }