From 1b26460fb3b5df5215cc1e6715661cbc7c950085 Mon Sep 17 00:00:00 2001 From: Alec Theriault Date: Thu, 31 Jan 2019 01:37:25 -0800 Subject: Use `.hie` files for the Hyperlinker backend (#977) # Summary This is a large architectural change to the Hyperlinker. * extract link (and now also type) information from `.hie` instead of doing ad-hoc SYB traversals of the `RenamedSource`. Also adds a superb type-on-hover feature (#715). * re-engineer the lexer to avoid needless string conversions. By going directly through GHC's `P` monad and taking bytestring slices, we avoid a ton of allocation and have better handling of position pragmas and CPP. In terms of performance, the Haddock side of things has gotten _much_ more efficient. Unfortunately, much of this is cancelled out by the increased GHC workload for generating `.hie` files. For the full set of boot libs (including `ghc`-the-library) * the sum of total time went down by 9-10% overall * the sum of total allocations went down by 6-7% # Motivation Haddock is moving towards working entirely over `.hi` and `.hie` files. This change means we no longer need the `RenamedSource` from `TypecheckedModule` (something which is _not_ in `.hi` files). # Details Along the way a bunch of things were fixed: * Cross package (and other) links are now more reliable (#496) * The lexer tries to recover from errors on every line (instead of at CPP boundaries) * `LINE`/`COLUMN` pragmas are taken into account * filter out zero length tokens before rendering * avoid recomputing the `ModuleName`-based `SrcMap` * remove the last use of `Documentation.Haddock.Utf8` (see #998) * restructure temporary folder logic for `.hi`/`.hie` model --- hypsrc-test/ref/src/Constructors.html | 1268 ++++++++++++++++++++++----------- 1 file changed, 835 insertions(+), 433 deletions(-) (limited to 'hypsrc-test/ref/src/Constructors.html') diff --git a/hypsrc-test/ref/src/Constructors.html b/hypsrc-test/ref/src/Constructors.html index e35ca0b1..6cdf07db 100644 --- a/hypsrc-test/ref/src/Constructors.html +++ b/hypsrc-test/ref/src/Constructors.html @@ -19,375 +19,489 @@ > data FooFoo = BarBar | BazBaz | QuuxQuux FooFoo IntInt newtype NorfNorf = NorfNorf (FooFoo, [FooFoo], FooFoo) barbar, bazbaz, quuxquux :: FooFoo barbar :: Foo +bar = BarFoo +Bar bazbaz :: Foo +baz = BazFoo +Baz quuxquux :: Foo +quux = QuuxFoo -> Int -> Foo +Quux quuxFoo +quux 00 unfoounfoo :: FooFoo -> IntInt unfoounfoo :: Foo -> Int +unfoo BarBar = 00 unfoounfoo BazBaz = 00 unfoounfoo (Quux fooQuux nfoo :: Foo +foo n :: Int +n)= 4242 *Int -> Int -> Int +forall a. Num a => a -> a -> a +* nInt +n +Int -> Int -> Int +forall a. Num a => a -> a -> a ++ unfooFoo -> Int +unfoo fooFoo +foo unnorfunnorf :: NorfNorf [FooFoo] unnorfunnorf :: Norf -> [Foo] +unnorf (NorfNorf (BarBar, xsxs :: [Foo] +xs, BarBar)= xs[Foo] +xs unnorfunnorf (NorfNorf (BazBaz, xsxs :: [Foo] +xs, BazBaz)= reverse[Foo] -> [Foo] +forall a. [a] -> [a] +reverse xs[Foo] +xs unnorfunnorf = undefined[Foo] +forall a. HasCallStack => a +undefined unnorf'unnorf' :: NorfNorf -> IntInt unnorf' xunnorf' :: Norf -> Int +unnorf' x :: Norf +x@(NorfNorf (f1f1 :: Foo +f1@(QuuxQuux _ nn :: Int +n), f2f2 :: Foo +f2@(QuuxQuux f3f3 :: Foo +f3 x'Int +x' +Int -> Int -> Int +forall a. Num a => a -> a -> a ++ nInt +n *Int -> Int -> Int +forall a. Num a => a -> a -> a +* unfooFoo -> Int +unfoo f1Foo +f1 +Int -> Int -> Int +forall a. Num a => a -> a -> a ++ auxFoo -> Int +aux f3Foo +f3 aux fxaux :: Foo -> Int +aux fx :: Foo +fx = unfooFoo -> Int +unfoo f2Foo +f2 *Int -> Int -> Int +forall a. Num a => a -> a -> a +* unfooFoo -> Int +unfoo fxFoo +fx *Int -> Int -> Int +forall a. Num a => a -> a -> a +* unfooFoo -> Int +unfoo f3Foo +f3 x'x' :: Int +x' = sum[Int] -> Int +forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a +sum .([Int] -> Int) -> (Norf -> [Int]) -> Norf -> Int +forall b c a. (b -> c) -> (a -> b) -> a -> c +. map(Foo -> Int) -> [Foo] -> [Int] +forall a b. (a -> b) -> [a] -> [b] +map unfooFoo -> Int +unfoo .([Foo] -> [Int]) -> (Norf -> [Foo]) -> Norf -> [Int] +forall b c a. (b -> c) -> (a -> b) -> a -> c +. unnorfNorf -> [Foo] +unnorf $(Norf -> Int) -> Norf -> Int +forall a b. (a -> b) -> a -> b +$ xNorf +x