Report markers on model creation.

See #34. This currently only works in non-readonly mode. Hopefully, that
will change in future Monaco versions.

build.sbt

@@ -51,6 +51,8 @@ lazy val example = project
   .settings(
     testDependencies,
     noPublish,
+    scalacOptions += "-Xlint",
+    scalacOptions += "-Ywarn-unused-import",
     test := {} // no need to run paiges tests.
   )
 

metadoc-js/src/main/scala/metadoc/MetadocApp.scala

@@ -24,14 +24,13 @@ object MetadocApp extends js.JSApp {
     } {
       // 1. Load editor
       val editor = openEditor(index)
+
+      // 2. Open initial file.
       val filename = index.files.find(_.endsWith("Doc.scala")).get
       for {
-        attrs <- MetadocAttributeService.fetchsAttributes(filename)
+        model <- MetadocTextModelService.modelReference(filename)
       } yield {
-        val model =
-          MetadocTextModelService.createModel(attrs.contents, attrs.filename)
-        // 2. Open intial file.
-        editor.setModel(model)
+        editor.setModel(model.`object`.textEditorModel)
       }
     }
   }
@@ -62,7 +61,7 @@ object MetadocApp extends js.JSApp {
     )
 
     val options = jsObject[IEditorConstructionOptions]
-    options.readOnly = true
+//    options.readOnly = true
     val overrides = jsObject[IEditorOverrideServices]
     val editorService = new MetadocEditorService
     overrides.textModelResolverService = MetadocTextModelService

metadoc-js/src/main/scala/metadoc/MetadocTextModelService.scala

@@ -3,15 +3,21 @@ package metadoc
 import scala.collection.mutable
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
+import scala.meta.internal.semantic.schema.Message
+import scala.meta.internal.semantic.schema.Message.Severity
 import scala.meta.internal.semantic.{schema => s}
+import scala.scalajs.js
+import scala.scalajs.js.JSON
 import scala.scalajs.js.annotation.ScalaJSDefined
 import monaco.Promise
 import monaco.Uri
 import monaco.common.IReference
 import monaco.editor.Editor
+import monaco.editor.IMarkerData
 import monaco.editor.IModel
 import monaco.services.ITextEditorModel
 import monaco.services.ITextModelResolverService
+import org.scalameta.logger
 
 @ScalaJSDefined
 object MetadocTextModelService extends ITextModelResolverService {
@@ -44,6 +50,33 @@ object MetadocTextModelService extends ITextModelResolverService {
         attrs <- MetadocAttributeService.fetchsAttributes(resource.path)
       } yield {
         val model = createModel(attrs.contents, resource)
+        // NOTE(olafurpg): It's not documented what `owner` does, but I suspect
+        // it's supposed to be a unique string for the application reporting that
+        // marker. For example, each linter/compiler application will use a
+        // custom owner.
+        val markers = attrs.messages.collect {
+          case message @ Message(Some(range), severity, msg) =>
+            val marker = jsObject[IMarkerData]
+            val start = model.getPositionAt(range.start)
+            val end = model.getPositionAt(range.end)
+            marker.message = msg
+            marker.startColumn = start.column
+            marker.startLineNumber = start.lineNumber
+            marker.endColumn = end.column
+            marker.endLineNumber = end.lineNumber
+            marker.severity = severity match {
+              case Severity.ERROR => monaco.Severity.Error
+              case Severity.WARNING => monaco.Severity.Warning
+              case Severity.INFO => monaco.Severity.Info
+              case _ => monaco.Severity.Ignore
+            }
+            logger.elem(message, JSON.stringify(marker))
+            marker
+        }
+        // PS: We might want to delay reporting markers. createModel is called
+        // in batch by services like reference provider, where we care less
+        // about seeing markers immediately.
+        Editor.setModelMarkers(model, "metadoc", js.Array(markers: _*))
         IReference(ITextEditorModel(model))
       }
     }