fluencelabs/aqua
1
0
Fork 0
mirror of https://github.com/fluencelabs/aqua.git synced 2025-06-23 03:21:33 +00:00
Code Issues Projects Releases Wiki Activity

Performance improvement: single parser instance (#254)

Browse Source
This commit is contained in:
Dima
2021-08-27 15:57:44 +03:00
committed by GitHub
parent 7e0fe470ec
commit dae234dc5a
49 changed files with 362 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
compiler/src/main/scala/aqua/compiler/AquaCompiler.scala
View File

@ -5,12 +5,13 @@ import aqua.linker.Linker
import aqua.model.AquaContext
import aqua.model.transform.TransformConfig
import aqua.model.transform.res.AquaRes
import aqua.parser.lift.LiftParser
import aqua.parser.Ast
import aqua.parser.lift.{LiftParser, Span}
import aqua.parser.{Ast, ParserError}
import aqua.semantics.Semantics
import aqua.semantics.header.HeaderSem
import cats.data.Validated.{validNec, Invalid, Valid}
import cats.data.{Chain, NonEmptyChain, NonEmptyMap, Validated, ValidatedNec}
import cats.parse.Parser0
import cats.syntax.applicative.*
import cats.syntax.flatMap.*
import cats.syntax.functor.*
@ -18,12 +19,13 @@ import cats.syntax.traverse.*
import cats.syntax.monoid.*
import cats.{Comonad, Monad, Monoid, Order}
import scribe.Logging
import cats.~>
object AquaCompiler extends Logging {
def compile[F[_]: Monad, E, I: Order, S[_]: Comonad](
sources: AquaSources[F, E, I],
liftI: (I, String) => LiftParser[S],
parser: I => String => ValidatedNec[ParserError[S], Ast[S]],
backend: Backend,
config: TransformConfig
): F[ValidatedNec[AquaError[I, E, S], Chain[AquaCompiled[I]]]] = {
@ -32,7 +34,7 @@ object AquaCompiler extends Logging {
type Ctx = NonEmptyMap[I, AquaContext]
type ValidatedCtx = ValidatedNec[Err, Ctx]
new AquaParser[F, E, I, S](sources, liftI)
new AquaParser[F, E, I, S](sources, parser)
.resolve[ValidatedCtx](mod =>
context =>
// Context with prepared imports
@ -95,12 +97,12 @@ object AquaCompiler extends Logging {
def compileTo[F[_]: Monad, E, I: Order, S[_]: Comonad, T](
sources: AquaSources[F, E, I],
liftI: (I, String) => LiftParser[S],
parser: I => String => ValidatedNec[ParserError[S], Ast[S]],
backend: Backend,
config: TransformConfig,
write: AquaCompiled[I] => F[Seq[Validated[E, T]]]
): F[ValidatedNec[AquaError[I, E, S], Chain[T]]] =
compile[F, E, I, S](sources, liftI, backend, config).flatMap {
compile[F, E, I, S](sources, parser, backend, config).flatMap {
case Valid(compiled) =>
compiled.map { ac =>
write(ac).map(

15
compiler/src/main/scala/aqua/compiler/AquaParser.scala
View File

@ -1,21 +1,23 @@
package aqua.compiler
import aqua.linker.{AquaModule, Modules}
import aqua.parser.Ast
import aqua.parser.{Ast, ParserError}
import aqua.parser.head.{FilenameExpr, ImportExpr}
import aqua.parser.lift.LiftParser
import aqua.parser.lift.{LiftParser, Span}
import cats.data.{Chain, NonEmptyChain, Validated, ValidatedNec}
import cats.parse.Parser0
import cats.syntax.applicative.*
import cats.syntax.flatMap.*
import cats.syntax.functor.*
import cats.syntax.traverse.*
import cats.{Comonad, Monad}
import scribe.Logging
import cats.~>
// TODO: add tests
class AquaParser[F[_]: Monad, E, I, S[_]: Comonad](
sources: AquaSources[F, E, I],
liftI: (I, String) => LiftParser[S]
parser: I => String => ValidatedNec[ParserError[S], Ast[S]]
) extends Logging {
type Body = Ast[S]
@ -26,8 +28,8 @@ class AquaParser[F[_]: Monad, E, I, S[_]: Comonad](
sources.sources
.map(
_.leftMap(_.map[Err](SourcesErr(_))).andThen(_.map { case (i, s) =>
implicit val lift: LiftParser[S] = liftI(i, s)
Ast.fromString[S](s).bimap(_.map[Err](ParserErr(_)), ast => Chain.one(i -> ast))
parser(i)(s)
.bimap(_.map[Err](ParserErr(_)), ast => Chain.one(i -> ast))
}.foldLeft(Validated.validNec[Err, Chain[(I, Body)]](Chain.nil))(_ combine _))
)
@ -84,8 +86,7 @@ class AquaParser[F[_]: Monad, E, I, S[_]: Comonad](
sources
.load(imp)
.map(_.leftMap(_.map[Err](SourcesErr(_))).andThen { src =>
implicit val lift: LiftParser[S] = liftI(imp, src)
Ast.fromString[S](src).leftMap(_.map[Err](ParserErr(_)))
parser(imp)(src).leftMap(_.map[Err](ParserErr(_)))
})
.flatMap {
case Validated.Valid(ast) =>