[svelte] reformat indent_size

GitOrigin-RevId: f65601289815dbe5abc284cb85e2bee077ae3a0a

.editorconfig

@@ -1,15 +1,6 @@
 # Editor configuration, see https://editorconfig.org
-root = true
-
 [*]
-indent_style = space
-indent_size = 4
 end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-
-[*.md]
-trim_trailing_whitespace = false
-
-[{*.bnf, *.flex, *.yml}]
+indent_style = space
 indent_size = 2
+charset = utf-8

src/main/java/dev/blachut/svelte/lang/SvelteBundle.kt

@@ -8,14 +8,13 @@ import org.jetbrains.annotations.PropertyKey
 private const val SVELTE_BUNDLE = "messages.SvelteBundle"
 
 object SvelteBundle : DynamicBundle(SVELTE_BUNDLE) {
+  @Suppress("SpreadOperator")
+  @JvmStatic
+  fun message(@PropertyKey(resourceBundle = SVELTE_BUNDLE) key: String, vararg params: Any) =
+    getMessage(key, *params)
 
-    @Suppress("SpreadOperator")
-    @JvmStatic
-    fun message(@PropertyKey(resourceBundle = SVELTE_BUNDLE) key: String, vararg params: Any) =
-        getMessage(key, *params)
-
-    @Suppress("SpreadOperator", "unused")
-    @JvmStatic
-    fun messagePointer(@PropertyKey(resourceBundle = SVELTE_BUNDLE) key: String, vararg params: Any) =
-        getLazyMessage(key, *params)
+  @Suppress("SpreadOperator", "unused")
+  @JvmStatic
+  fun messagePointer(@PropertyKey(resourceBundle = SVELTE_BUNDLE) key: String, vararg params: Any) =
+    getLazyMessage(key, *params)
 }

src/main/java/dev/blachut/svelte/lang/SvelteDirectiveAnnotator.kt

@@ -24,97 +24,100 @@ import dev.blachut.svelte.lang.directives.ShorthandLetReference
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap
 
 class SvelteDirectiveAnnotator : Annotator {
-    override fun annotate(element: PsiElement, holder: AnnotationHolder) {
-        if (element !is XmlAttribute) return
+  override fun annotate(element: PsiElement, holder: AnnotationHolder) {
+    if (element !is XmlAttribute) return
 
-        val highlighter = JSAnnotatingVisitor.getHighlighter(element)
+    val highlighter = JSAnnotatingVisitor.getHighlighter(element)
 
-        for (ref in element.references) {
-            val attrKey = when (ref) {
-                is PsiMultiReference -> {
-                    val innerRef = ref.references.find { it is ScopeReference } ?: continue
-                    highlight(innerRef, highlighter)
-                }
-                is ScopeReference -> {
-                    highlight(ref, highlighter)
-                }
-                is ShorthandLetReference -> {
-                    highlight(ref, highlighter)
-                }
-                else -> continue
-            }
+    for (ref in element.references) {
+      val attrKey = when (ref) {
+        is PsiMultiReference -> {
+          val innerRef = ref.references.find { it is ScopeReference } ?: continue
+          highlight(innerRef, highlighter)
+        }
+        is ScopeReference -> {
+          highlight(ref, highlighter)
+        }
+        is ShorthandLetReference -> {
+          highlight(ref, highlighter)
+        }
+        else -> continue
+      }
 
-            val elementRange = ref.element.textRange
-            val refRange = ref.rangeInElement.shiftRight(elementRange.startOffset)
+      val elementRange = ref.element.textRange
+      val refRange = ref.rangeInElement.shiftRight(elementRange.startOffset)
 
-            if (!refRange.intersects(elementRange)) continue
+      if (!refRange.intersects(elementRange)) continue
 
-            if (attrKey != null) {
-                holder.newSilentAnnotation(HighlightSeverity.INFORMATION).range(refRange).textAttributes(attrKey)
-                    .create()
-            } else if (!ref.isSoft && ref.resolve() == null) {
-                val message = XmlHighlightVisitor.getErrorDescription(ref)
-                holder.newAnnotation(HighlightSeverity.ERROR, message).range(refRange)
-                    .highlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL).create()
-            }
-        }
+      if (attrKey != null) {
+        holder.newSilentAnnotation(HighlightSeverity.INFORMATION).range(refRange).textAttributes(attrKey)
+          .create()
+      }
+      else if (!ref.isSoft && ref.resolve() == null) {
+        val message = XmlHighlightVisitor.getErrorDescription(ref)
+        holder.newAnnotation(HighlightSeverity.ERROR, message).range(refRange)
+          .highlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL).create()
+      }
     }
+  }
 
-    private fun highlight(reference: PsiReference, highlighter: JSHighlighter): TextAttributesKey? {
-        val resolve = reference.resolve() ?: return null
-        return JSSemanticHighlightingVisitor.buildHighlightForResolveResult(
-            resolve,
-            reference.element,
-        )?.getAttributesKey(highlighter)
-    }
+  private fun highlight(reference: PsiReference, highlighter: JSHighlighter): TextAttributesKey? {
+    val resolve = reference.resolve() ?: return null
+    return JSSemanticHighlightingVisitor.buildHighlightForResolveResult(
+      resolve,
+      reference.element,
+    )?.getAttributesKey(highlighter)
+  }
 
-    // based on JSSemanticHighlightingUtil.highlight(JSPsiReferenceElement node, JSHighlighter highlighter, AnnotationHolder holder)
-    private fun highlight(reference: PsiPolyVariantReference, highlighter: JSHighlighter): TextAttributesKey? {
-        val results: Array<ResolveResult> = reference.multiResolve(false)
-        if (results.isNotEmpty()) {
-            if (JSResolveResult.isTooManyCandidatesResult(results)) {
-//        } else if (JSSemanticHighlightingUtil.isGlobalUndefined(node)) {
-            } else {
-                var countByTypes = Object2IntOpenHashMap<JSHighlightDescriptor?>()
-                var tsdOccurred = false
-                for (result in results) {
-                    val resolve = result.element
-                    if (resolve != null) {
-                        val file = resolve.containingFile
-                        val isFromTsd = file != null && TypeScriptUtil.isDefinitionFile(file)
-                        if (isFromTsd && !tsdOccurred) {
-                            tsdOccurred = true
-                            countByTypes = Object2IntOpenHashMap()
-                        }
-                        if (!tsdOccurred || isFromTsd) {
-                            val info = JSSemanticHighlightingVisitor.buildHighlightForResolveResult(
-                                resolve,
-                                reference.element,
-                            )
-                            if (info != null) {
-                                countByTypes.put(info, countByTypes.getInt(info) + 1)
-                            }
-                        }
-                    }
-                }
-
-                val maxCountRef = Ref.create(0)
-                val infoRef: Ref<JSHighlightDescriptor?> = Ref.create(null)
-                countByTypes.object2IntEntrySet().forEach { entry ->
-                    val key = entry.key
-                    val count = entry.intValue
-                    if (count > maxCountRef.get()) {
-                        maxCountRef.set(count)
-                        infoRef.set(key)
-                    } else if (count == maxCountRef.get() && infoRef.get()!!.debugName > key!!.debugName) {
-                        infoRef.set(key)
-                    }
-                }
-
-                return infoRef.get()?.getAttributesKey(highlighter)
+  // based on JSSemanticHighlightingUtil.highlight(JSPsiReferenceElement node, JSHighlighter highlighter, AnnotationHolder holder)
+  private fun highlight(reference: PsiPolyVariantReference, highlighter: JSHighlighter): TextAttributesKey? {
+    val results: Array<ResolveResult> = reference.multiResolve(false)
+    if (results.isNotEmpty()) {
+      if (JSResolveResult.isTooManyCandidatesResult(results)) {
+        //        } else if (JSSemanticHighlightingUtil.isGlobalUndefined(node)) {
+      }
+      else {
+        var countByTypes = Object2IntOpenHashMap<JSHighlightDescriptor?>()
+        var tsdOccurred = false
+        for (result in results) {
+          val resolve = result.element
+          if (resolve != null) {
+            val file = resolve.containingFile
+            val isFromTsd = file != null && TypeScriptUtil.isDefinitionFile(file)
+            if (isFromTsd && !tsdOccurred) {
+              tsdOccurred = true
+              countByTypes = Object2IntOpenHashMap()
+            }
+            if (!tsdOccurred || isFromTsd) {
+              val info = JSSemanticHighlightingVisitor.buildHighlightForResolveResult(
+                resolve,
+                reference.element,
+              )
+              if (info != null) {
+                countByTypes.put(info, countByTypes.getInt(info) + 1)
+              }
             }
+          }
         }
 
-        return null
+        val maxCountRef = Ref.create(0)
+        val infoRef: Ref<JSHighlightDescriptor?> = Ref.create(null)
+        countByTypes.object2IntEntrySet().forEach { entry ->
+          val key = entry.key
+          val count = entry.intValue
+          if (count > maxCountRef.get()) {
+            maxCountRef.set(count)
+            infoRef.set(key)
+          }
+          else if (count == maxCountRef.get() && infoRef.get()!!.debugName > key!!.debugName) {
+            infoRef.set(key)
+          }
+        }
+
+        return infoRef.get()?.getAttributesKey(highlighter)
+      }
     }
+
+    return null
+  }
 }

src/main/java/dev/blachut/svelte/lang/SvelteFrameworkHandler.kt

@@ -9,26 +9,27 @@ import com.intellij.psi.PsiElement
 import dev.blachut.svelte.lang.psi.SvelteJSReferenceExpression
 
 class SvelteFrameworkHandler : FrameworkIndexingHandler() {
-    override fun addTypeFromResolveResult(
-        evaluator: JSTypeEvaluator,
-        context: JSEvaluateContext,
-        result: PsiElement
-    ): Boolean {
-        val expression = context.processedExpression
-        if (result is JSVariable && expression is SvelteJSReferenceExpression && expression.isSubscribedReference) {
-            try {
-                val storeType = result.jsType?.asRecordType() ?: return false
-                val subscribeMethod =
-                    storeType.findPropertySignature("subscribe")?.jsType as? JSFunctionType ?: return false
-                val subscriberFunction =
-                    subscribeMethod.parameters[0].inferredType?.substitute() as? JSFunctionType ?: return false
-                val storeContentType = subscriberFunction.parameters[0].inferredType ?: return false
+  override fun addTypeFromResolveResult(
+    evaluator: JSTypeEvaluator,
+    context: JSEvaluateContext,
+    result: PsiElement
+  ): Boolean {
+    val expression = context.processedExpression
+    if (result is JSVariable && expression is SvelteJSReferenceExpression && expression.isSubscribedReference) {
+      try {
+        val storeType = result.jsType?.asRecordType() ?: return false
+        val subscribeMethod =
+          storeType.findPropertySignature("subscribe")?.jsType as? JSFunctionType ?: return false
+        val subscriberFunction =
+          subscribeMethod.parameters[0].inferredType?.substitute() as? JSFunctionType ?: return false
+        val storeContentType = subscriberFunction.parameters[0].inferredType ?: return false
 
-                evaluator.addType(storeContentType)
-                return true
-            } catch (e: Exception) {
-            }
-        }
-        return false
+        evaluator.addType(storeContentType)
+        return true
+      }
+      catch (e: Exception) {
+      }
     }
+    return false
+  }
 }

src/main/java/dev/blachut/svelte/lang/SvelteHTMLLanguage.java

@@ -9,26 +9,26 @@
  * Externally it's name is just "Svelte" because it's the root language of Svelte files
  */
 public class SvelteHTMLLanguage extends HTMLLanguage {
-    public static final SvelteHTMLLanguage INSTANCE = new SvelteHTMLLanguage();
+  public static final SvelteHTMLLanguage INSTANCE = new SvelteHTMLLanguage();
 
-    private SvelteHTMLLanguage() {
-        super(HTMLLanguage.INSTANCE, "SvelteHTML");
-    }
+  private SvelteHTMLLanguage() {
+    super(HTMLLanguage.INSTANCE, "SvelteHTML");
+  }
 
-    @NotNull
-    @Override
-    public String getDisplayName() {
-        return "Svelte";
-    }
+  @NotNull
+  @Override
+  public String getDisplayName() {
+    return "Svelte";
+  }
 
-    @Override
-    public boolean isCaseSensitive() {
-        return true;
-    }
+  @Override
+  public boolean isCaseSensitive() {
+    return true;
+  }
 
-    @Nullable
-    @Override
-    public LanguageFileType getAssociatedFileType() {
-        return SvelteHtmlFileType.INSTANCE;
-    }
+  @Nullable
+  @Override
+  public LanguageFileType getAssociatedFileType() {
+    return SvelteHtmlFileType.INSTANCE;
+  }
 }

src/main/java/dev/blachut/svelte/lang/SvelteHtmlFileType.kt

@@ -5,13 +5,13 @@ import icons.SvelteIcons
 import javax.swing.Icon
 
 class SvelteHtmlFileType private constructor() : LanguageFileType(SvelteHTMLLanguage.INSTANCE) {
-    override fun getName(): String = "Svelte"
-    override fun getDescription(): String = SvelteBundle.message("svelte.file.type.description")
-    override fun getDefaultExtension(): String = "svelte"
-    override fun getIcon(): Icon = SvelteIcons.Desaturated
+  override fun getName(): String = "Svelte"
+  override fun getDescription(): String = SvelteBundle.message("svelte.file.type.description")
+  override fun getDefaultExtension(): String = "svelte"
+  override fun getIcon(): Icon = SvelteIcons.Desaturated
 
-    companion object {
-        @JvmField
-        val INSTANCE = SvelteHtmlFileType()
-    }
+  companion object {
+    @JvmField
+    val INSTANCE = SvelteHtmlFileType()
+  }
 }

src/main/java/dev/blachut/svelte/lang/SvelteIndexedFileTypeProvider.kt

@@ -4,5 +4,5 @@ import com.intellij.lang.javascript.index.IndexedFileTypeProvider
 import com.intellij.openapi.fileTypes.FileType
 
 class SvelteIndexedFileTypeProvider : IndexedFileTypeProvider {
-    override fun getFileTypesToIndex(): Array<FileType> = arrayOf(SvelteHtmlFileType.INSTANCE)
+  override fun getFileTypesToIndex(): Array<FileType> = arrayOf(SvelteHtmlFileType.INSTANCE)
 }

src/main/java/dev/blachut/svelte/lang/SvelteJSAnalysisHandlersFactory.kt

@@ -16,24 +16,24 @@ import dev.blachut.svelte.lang.codeInsight.SvelteJSReferenceChecker
 import dev.blachut.svelte.lang.codeInsight.SvelteReactiveDeclarationsUtil
 
 class SvelteJSAnalysisHandlersFactory : ES6AnalysisHandlersFactory() {
-    override fun getReferenceChecker(reporter: JSProblemReporter<*>): JSReferenceChecker {
-        return SvelteJSReferenceChecker(reporter)
-    }
+  override fun getReferenceChecker(reporter: JSProblemReporter<*>): JSReferenceChecker {
+    return SvelteJSReferenceChecker(reporter)
+  }
 
-    override fun createKeywordHighlighterVisitor(
-        holder: HighlightInfoHolder,
-        dialectOptionHolder: DialectOptionHolder
-    ): JSKeywordHighlighterVisitor {
-        return SvelteKeywordHighlighterVisitor(holder)
-    }
+  override fun createKeywordHighlighterVisitor(
+    holder: HighlightInfoHolder,
+    dialectOptionHolder: DialectOptionHolder
+  ): JSKeywordHighlighterVisitor {
+    return SvelteKeywordHighlighterVisitor(holder)
+  }
 
-    override fun createAnnotatingVisitor(psiElement: PsiElement, holder: AnnotationHolder): JSAnnotatingVisitor {
-        return object : ES6AnnotatingVisitor(psiElement, holder) {
-            override fun visitJSLabeledStatement(node: JSLabeledStatement) {
-                if (node.label != SvelteReactiveDeclarationsUtil.REACTIVE_LABEL) {
-                    super.visitJSLabeledStatement(node)
-                }
-            }
+  override fun createAnnotatingVisitor(psiElement: PsiElement, holder: AnnotationHolder): JSAnnotatingVisitor {
+    return object : ES6AnnotatingVisitor(psiElement, holder) {
+      override fun visitJSLabeledStatement(node: JSLabeledStatement) {
+        if (node.label != SvelteReactiveDeclarationsUtil.REACTIVE_LABEL) {
+          super.visitJSLabeledStatement(node)
         }
+      }
     }
+  }
 }