diff --git a/CHANGELOG.md b/CHANGELOG.md index 2a2b892..465cf0f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,8 @@ ### Removed ### Fixed +- Rudimentary Torque Shader Language (TLSL) support + - Syntax highlighting and checking ### Security diff --git a/build.gradle.kts b/build.gradle.kts index 536a942..0749162 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,4 +1,6 @@ import org.jetbrains.changelog.Changelog +import org.jetbrains.grammarkit.tasks.GenerateLexerTask +import org.jetbrains.grammarkit.tasks.GenerateParserTask import org.jetbrains.intellij.tasks.PublishPluginTask import org.jetbrains.kotlin.gradle.tasks.KotlinCompile @@ -120,6 +122,32 @@ tasks { outputs.dir("${targetRoot.get()}${pathToPsiRoot.get()}") } + register("generateTslLexer").configure { + sourceFile.set(file("src/org/lukasj/idea/torquescript/grammar/TorqueShaderLanguage.flex")) + + targetDir.set("gen/org/lukasj/idea/torquescript/lexer") + targetClass.set("TslLexer") + + purgeOldFiles.set(true) + + outputs.file("${targetDir.get()}/${targetClass.get()}.java") + } + + register("generateTslParser").configure { + sourceFile.set(file("src/org/lukasj/idea/torquescript/grammar/TorqueShaderLanguage.bnf")) + + targetRoot.set("gen") + + pathToParser.set("/org/lukasj/idea/torquescript/parser/TslParser") + + pathToPsiRoot.set("/org/lukasj/idea/torquescript/psi") + + purgeOldFiles.set(true) + + outputs.file("${targetRoot.get()}${pathToParser.get()}.java") + outputs.dir("${targetRoot.get()}${pathToPsiRoot.get()}") + } + // https://plugins.jetbrains.com/docs/intellij/dynamic-plugins.html#diagnosing-leaks runIde { jvmArgs = mutableListOf("-XX:+UnlockDiagnosticVMOptions") @@ -145,7 +173,7 @@ tasks { // Specify the right jvm target for Kotlin withType().configureEach { - dependsOn("generateLexer", "generateParser") + dependsOn("generateLexer", "generateParser", "generateTslLexer", "generateTslParser") kotlinOptions { jvmTarget = "17" freeCompilerArgs = listOf("-Xjvm-default=all") diff --git a/gradle.properties b/gradle.properties index ac31271..4ceb411 100644 --- a/gradle.properties +++ b/gradle.properties @@ -2,7 +2,7 @@ kotlin.code.style=official kotlin.stdlib.default.dependency = false publishToken=token -publishChannel=stable +publishChannel=beta pluginVersion=1.14.8 legacyBuild=false \ No newline at end of file diff --git a/resources/META-INF/extensions.xml b/resources/META-INF/extensions.xml index 2680025..fd6f82b 100644 --- a/resources/META-INF/extensions.xml +++ b/resources/META-INF/extensions.xml @@ -16,7 +16,13 @@ fieldName="INSTANCE" language="TAML" extensions="module"/> + + @@ -29,7 +35,19 @@ implementationClass="org.lukasj.idea.torquescript.annotator.TamlPathAnnotator"/> - + + + + + + + + + + diff --git a/src/org/lukasj/idea/torquescript/TslFileType.kt b/src/org/lukasj/idea/torquescript/TslFileType.kt new file mode 100644 index 0000000..32274db --- /dev/null +++ b/src/org/lukasj/idea/torquescript/TslFileType.kt @@ -0,0 +1,19 @@ +package org.lukasj.idea.torquescript + +import com.intellij.openapi.fileTypes.LanguageFileType +import icons.TSIcons + +class TslFileType : LanguageFileType(TslLanguage.INSTANCE) { + override fun getName() = "Torque Shader Language" + + override fun getDescription() = "Torque Shader Language file" + + override fun getDefaultExtension() = "tlsl" + + override fun getIcon() = TSIcons.FILE + + companion object { + @JvmField + val INSTANCE = TslFileType() + } +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/TslLanguage.kt b/src/org/lukasj/idea/torquescript/TslLanguage.kt new file mode 100644 index 0000000..1c731df --- /dev/null +++ b/src/org/lukasj/idea/torquescript/TslLanguage.kt @@ -0,0 +1,16 @@ +package org.lukasj.idea.torquescript + +import com.intellij.lang.Language +import com.intellij.lang.xml.XMLLanguage +import com.intellij.lang.xml.XMLParserDefinition +import com.intellij.psi.FileViewProvider +import com.intellij.psi.impl.source.xml.XmlFileImpl +import com.intellij.psi.tree.IElementType +import com.intellij.psi.tree.IFileElementType + +class TslLanguage : Language("Torque Shader Language") { + companion object { + @JvmField + val INSTANCE = TslLanguage() + } +} diff --git a/src/org/lukasj/idea/torquescript/TslSyntaxHighlighterFactory.kt b/src/org/lukasj/idea/torquescript/TslSyntaxHighlighterFactory.kt new file mode 100644 index 0000000..599a3b1 --- /dev/null +++ b/src/org/lukasj/idea/torquescript/TslSyntaxHighlighterFactory.kt @@ -0,0 +1,12 @@ +package org.lukasj.idea.torquescript + +import com.intellij.openapi.fileTypes.SyntaxHighlighter +import com.intellij.openapi.fileTypes.SyntaxHighlighterFactory +import com.intellij.openapi.project.Project +import com.intellij.openapi.vfs.VirtualFile +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlighter + +class TslSyntaxHighlighterFactory : SyntaxHighlighterFactory() { + override fun getSyntaxHighlighter(project: Project?, virtualFile: VirtualFile?): SyntaxHighlighter = + TslSyntaxHighlighter() +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/annotator/TamlPathAnnotator.kt b/src/org/lukasj/idea/torquescript/annotator/TamlPathAnnotator.kt index 83b8f83..9ca7b36 100644 --- a/src/org/lukasj/idea/torquescript/annotator/TamlPathAnnotator.kt +++ b/src/org/lukasj/idea/torquescript/annotator/TamlPathAnnotator.kt @@ -4,17 +4,10 @@ import com.intellij.lang.annotation.AnnotationHolder import com.intellij.lang.annotation.Annotator import com.intellij.lang.annotation.HighlightSeverity import com.intellij.openapi.editor.colors.CodeInsightColors -import com.intellij.openapi.util.TextRange import com.intellij.psi.PsiElement import com.intellij.psi.util.elementType -import com.intellij.psi.xml.XmlAttributeValue import com.intellij.psi.xml.XmlElementType -import com.intellij.psi.xml.XmlTokenType -import com.intellij.refactoring.suggested.startOffset -import org.lukasj.idea.torquescript.ModuleFileType -import org.lukasj.idea.torquescript.TamlFileType import org.lukasj.idea.torquescript.TamlLanguage -import org.lukasj.idea.torquescript.psi.TSLiteralExpression import org.lukasj.idea.torquescript.reference.TSFileReference class TamlPathAnnotator : Annotator { diff --git a/src/org/lukasj/idea/torquescript/completion/TSCompletionContributor.kt b/src/org/lukasj/idea/torquescript/completion/TSCompletionContributor.kt index 732ec14..2ea8b68 100644 --- a/src/org/lukasj/idea/torquescript/completion/TSCompletionContributor.kt +++ b/src/org/lukasj/idea/torquescript/completion/TSCompletionContributor.kt @@ -8,11 +8,7 @@ import com.intellij.patterns.StandardPatterns import com.intellij.psi.PsiElement import com.intellij.psi.TokenType import com.intellij.psi.tree.TokenSet -import com.intellij.psi.xml.XmlAttributeValue -import com.intellij.psi.xml.XmlTokenType import org.lukasj.idea.torquescript.TSLanguage -import org.lukasj.idea.torquescript.TamlLanguage -import org.lukasj.idea.torquescript.psi.TSFieldAssignment import org.lukasj.idea.torquescript.psi.TSLiteralExpression import org.lukasj.idea.torquescript.psi.TSProperty import org.lukasj.idea.torquescript.psi.TSTypes diff --git a/src/org/lukasj/idea/torquescript/completion/TamlCompletionContributor.kt b/src/org/lukasj/idea/torquescript/completion/TamlCompletionContributor.kt index d1fd1c5..ce9d2ed 100644 --- a/src/org/lukasj/idea/torquescript/completion/TamlCompletionContributor.kt +++ b/src/org/lukasj/idea/torquescript/completion/TamlCompletionContributor.kt @@ -4,18 +4,8 @@ import com.intellij.codeInsight.completion.CompletionContributor import com.intellij.codeInsight.completion.CompletionType import com.intellij.patterns.ElementPattern import com.intellij.patterns.PlatformPatterns.psiElement -import com.intellij.patterns.StandardPatterns import com.intellij.psi.PsiElement -import com.intellij.psi.TokenType -import com.intellij.psi.tree.TokenSet -import com.intellij.psi.xml.XmlAttributeValue import com.intellij.psi.xml.XmlTokenType -import org.lukasj.idea.torquescript.TSLanguage -import org.lukasj.idea.torquescript.TamlLanguage -import org.lukasj.idea.torquescript.psi.TSFieldAssignment -import org.lukasj.idea.torquescript.psi.TSLiteralExpression -import org.lukasj.idea.torquescript.psi.TSProperty -import org.lukasj.idea.torquescript.psi.TSTypes class TamlCompletionContributor : CompletionContributor() { diff --git a/src/org/lukasj/idea/torquescript/editor/TSUsageTypeProvider.kt b/src/org/lukasj/idea/torquescript/editor/TSUsageTypeProvider.kt index f6e7692..8f45667 100644 --- a/src/org/lukasj/idea/torquescript/editor/TSUsageTypeProvider.kt +++ b/src/org/lukasj/idea/torquescript/editor/TSUsageTypeProvider.kt @@ -8,7 +8,6 @@ import com.intellij.usages.impl.rules.UsageType import com.intellij.usages.impl.rules.UsageTypeProvider import org.lukasj.idea.torquescript.psi.TSLiteralExpression import org.lukasj.idea.torquescript.psi.TSTypes -import org.lukasj.idea.torquescript.psi.impl.TSFunctionIdentifierElementImpl import org.lukasj.idea.torquescript.psi.impl.TSFunctionStatementElementImpl object TSUsageTypes { diff --git a/src/org/lukasj/idea/torquescript/editor/TslBraceMatcher.kt b/src/org/lukasj/idea/torquescript/editor/TslBraceMatcher.kt new file mode 100644 index 0000000..49eedc9 --- /dev/null +++ b/src/org/lukasj/idea/torquescript/editor/TslBraceMatcher.kt @@ -0,0 +1,23 @@ +package org.lukasj.idea.torquescript.editor + +import com.intellij.lang.BracePair +import com.intellij.lang.PairedBraceMatcher +import com.intellij.psi.PsiFile +import com.intellij.psi.tree.IElementType +import org.lukasj.idea.torquescript.psi.TslTypes + +class TslBraceMatcher : PairedBraceMatcher { + override fun getPairs(): Array = BRACE_PAIRS + + override fun isPairedBracesAllowedBeforeType(lbraceType: IElementType, contextType: IElementType?) = true + + override fun getCodeConstructStart(file: PsiFile?, openingBraceOffset: Int) = openingBraceOffset + + companion object { + val BRACE_PAIRS = arrayOf( + BracePair(TslTypes.LBRACE, TslTypes.RBRACE, true), + BracePair(TslTypes.LPAREN, TslTypes.RPAREN, true), + BracePair(TslTypes.LBRACK, TslTypes.RBRACK, true), + ) + } +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/editor/TslColorSettingsPage.kt b/src/org/lukasj/idea/torquescript/editor/TslColorSettingsPage.kt new file mode 100644 index 0000000..1942286 --- /dev/null +++ b/src/org/lukasj/idea/torquescript/editor/TslColorSettingsPage.kt @@ -0,0 +1,98 @@ +package org.lukasj.idea.torquescript.editor + +import com.intellij.openapi.editor.colors.TextAttributesKey +import com.intellij.openapi.fileTypes.SyntaxHighlighter +import com.intellij.openapi.options.colors.AttributesDescriptor +import com.intellij.openapi.options.colors.ColorDescriptor +import com.intellij.openapi.options.colors.ColorSettingsPage +import icons.TSIcons +import javax.swing.Icon + +class TslColorSettingsPage : ColorSettingsPage { + override fun getAttributeDescriptors(): Array = DESCRIPTORS + + override fun getColorDescriptors(): Array = ColorDescriptor.EMPTY_ARRAY + + override fun getDisplayName(): String = "Torque Shader Language" + + override fun getIcon(): Icon = TSIcons.FILE + + override fun getHighlighter(): SyntaxHighlighter = TslSyntaxHighlighter() + + override fun getDemoText(): String = """ +Blueprint "diffuse" +{ + struct VertData{ + float3 pos : POSITION; + float2 texCoord : TEXCOORD0; + }; + + struct ConnectData{ + float4 hpos : SV_Position; + float2 texCoord : TEXCOORD0; + }; + + struct FragOut{ + float4 col : SV_Target; + }; + + VertexShader + { + #pragma entry "main" + + uniform float4x4 modelview; + + ConnectData main(VertData IN) + { + ConnectData OUT; + + OUT.hpos = mul(modelview, float4(IN.pos, 1.0)); + OUT.texCoord = IN.texCoord; + + return OUT; + }; + }; + + PixelShader + { + #pragma entry "main" + + uniform sampler2D _inTex; + + FragOut main(ConnectData IN) + { + FragOut OUT; + OUT.col = Sample(_inTex, IN.texCoord); + return OUT; + }; + }; +}; +""" + + override fun getAdditionalHighlightingTagToDescriptorMap(): MutableMap? = null + + companion object { + private val DESCRIPTORS = arrayOf( + AttributesDescriptor("Identifier", TslSyntaxHighlightingColors.IDENTIFIER), + AttributesDescriptor("Function declaration", TslSyntaxHighlightingColors.FUNCTION_DECLARATION), + AttributesDescriptor("Function call", TslSyntaxHighlightingColors.FUNCTION_CALL), + AttributesDescriptor("Intrinsic function call", TslSyntaxHighlightingColors.INTRINSIC_FUNCTION_CALL), + AttributesDescriptor("Semantic", TslSyntaxHighlightingColors.SEMANTIC), + AttributesDescriptor("Struct type", TslSyntaxHighlightingColors.STRUCT_TYPES), + AttributesDescriptor("Number", TslSyntaxHighlightingColors.NUMBER), + AttributesDescriptor("String", TslSyntaxHighlightingColors.STRING), + AttributesDescriptor("Keyword", TslSyntaxHighlightingColors.KEYWORD), + AttributesDescriptor("Operator", TslSyntaxHighlightingColors.OPERATOR), + AttributesDescriptor("Semicolon", TslSyntaxHighlightingColors.SEMICOLON), + AttributesDescriptor("Dot", TslSyntaxHighlightingColors.DOT), + AttributesDescriptor("Comma", TslSyntaxHighlightingColors.COMMA), + AttributesDescriptor("Colon", TslSyntaxHighlightingColors.COLON), + AttributesDescriptor("Line comment", TslSyntaxHighlightingColors.LINE_COMMENT), + AttributesDescriptor("Block comment", TslSyntaxHighlightingColors.BLOCK_COMMENT), + AttributesDescriptor("Parentheses", TslSyntaxHighlightingColors.PARENTHESES), + AttributesDescriptor("Braces", TslSyntaxHighlightingColors.BRACES), + AttributesDescriptor("Brackets", TslSyntaxHighlightingColors.BRACKETS), + AttributesDescriptor("Bad value", TslSyntaxHighlightingColors.BAD_CHARACTER) + ) + } +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/editor/TslSyntaxHighlighter.kt b/src/org/lukasj/idea/torquescript/editor/TslSyntaxHighlighter.kt new file mode 100644 index 0000000..82b055f --- /dev/null +++ b/src/org/lukasj/idea/torquescript/editor/TslSyntaxHighlighter.kt @@ -0,0 +1,56 @@ +package org.lukasj.idea.torquescript.editor + +import com.intellij.lexer.Lexer +import com.intellij.openapi.editor.colors.TextAttributesKey +import com.intellij.openapi.fileTypes.SyntaxHighlighterBase +import com.intellij.psi.TokenType +import com.intellij.psi.tree.IElementType +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.ASSIGNMENT_OPERATOR +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.BAD_CHARACTER +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.BLOCK_COMMENT +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.BRACES +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.BRACKETS +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.COLON +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.IDENTIFIER +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.KEYWORD +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.LINE_COMMENT +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.NUMBER +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.OPERATOR +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.PARENTHESES +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.SEMANTIC +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.SEMICOLON +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.STRING +import org.lukasj.idea.torquescript.editor.TslSyntaxHighlightingColors.STRUCT_TYPES +import org.lukasj.idea.torquescript.lexer.TslLexerAdapter +import org.lukasj.idea.torquescript.parser.TslParserDefinition +import org.lukasj.idea.torquescript.psi.TslTypes + + +class TslSyntaxHighlighter : SyntaxHighlighterBase() { + + override fun getHighlightingLexer(): Lexer = TslLexerAdapter() + + override fun getTokenHighlights(tokenType: IElementType?): Array = pack(ATTRIBUTES[tokenType]) + + companion object { + private val ATTRIBUTES = HashMap() + + init + { + fillMap(ATTRIBUTES, LINE_COMMENT, TslTypes.LINE_COMMENT) + fillMap(ATTRIBUTES, BLOCK_COMMENT, TslTypes.BLOCK_COMMENT) + fillMap(ATTRIBUTES, PARENTHESES, TslTypes.LPAREN, TslTypes.RPAREN) + fillMap(ATTRIBUTES, BRACES, TslTypes.LBRACE, TslTypes.RBRACE) + fillMap(ATTRIBUTES, BRACKETS, TslTypes.LBRACK, TslTypes.RBRACK) + fillMap(ATTRIBUTES, BAD_CHARACTER, TokenType.BAD_CHARACTER) + fillMap(ATTRIBUTES, IDENTIFIER, TslTypes.IDENT) + fillMap(ATTRIBUTES, COLON, TslTypes.COLON) + fillMap(ATTRIBUTES, SEMICOLON, TslTypes.STMT_SEPARATOR) + fillMap(ATTRIBUTES, TslParserDefinition.OPERATORS, OPERATOR) + fillMap(ATTRIBUTES, TslParserDefinition.KEYWORDS, KEYWORD) + fillMap(ATTRIBUTES, TslParserDefinition.NUMBERS, NUMBER) + fillMap(ATTRIBUTES, TslParserDefinition.SEMANTICS, SEMANTIC) + fillMap(ATTRIBUTES, TslParserDefinition.ASSIGNMENT_OPERATORS, ASSIGNMENT_OPERATOR) + } + } +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/editor/TslSyntaxHighlightingColors.kt b/src/org/lukasj/idea/torquescript/editor/TslSyntaxHighlightingColors.kt new file mode 100644 index 0000000..22502ab --- /dev/null +++ b/src/org/lukasj/idea/torquescript/editor/TslSyntaxHighlightingColors.kt @@ -0,0 +1,100 @@ +package org.lukasj.idea.torquescript.editor + +import com.intellij.openapi.editor.DefaultLanguageHighlighterColors +import com.intellij.openapi.editor.HighlighterColors +import com.intellij.openapi.editor.colors.TextAttributesKey + +object TslSyntaxHighlightingColors { + val FUNCTION_DECLARATION = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_FUNCTION_DECLARATION", + DefaultLanguageHighlighterColors.FUNCTION_DECLARATION + ) + val FUNCTION_CALL = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_FUNCTION_CALL", + DefaultLanguageHighlighterColors.FUNCTION_CALL + ) + val INTRINSIC_FUNCTION_CALL = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_BUILTIN_FUNCTION_CALL", + DefaultLanguageHighlighterColors.PREDEFINED_SYMBOL + ) + val SEMANTIC = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_SEMANTIC", + DefaultLanguageHighlighterColors.CONSTANT + ) + val STRUCT_TYPES = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_STRUCT_TYPES", + DefaultLanguageHighlighterColors.CLASS_NAME + ) + val PARENTHESES = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_PARENTHESES", + DefaultLanguageHighlighterColors.PARENTHESES + ) + + val BRACES = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_BRACES", + DefaultLanguageHighlighterColors.BRACES + ) + + val BRACKETS = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_BRACKETS", + DefaultLanguageHighlighterColors.BRACKETS + ) + + val LINE_COMMENT = + TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_LINE_COMMENT", + DefaultLanguageHighlighterColors.LINE_COMMENT + ) + + val BLOCK_COMMENT = + TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_BLOCK_COMMENT", + DefaultLanguageHighlighterColors.BLOCK_COMMENT + ) + + val SEMICOLON = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_SEMICOLON", + DefaultLanguageHighlighterColors.SEMICOLON + ) + val DOT = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_DOT", + DefaultLanguageHighlighterColors.DOT + ) + val COMMA = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_COMMA", + DefaultLanguageHighlighterColors.COMMA + ) + val COLON = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_COLON", + HighlighterColors.TEXT + ) + val IDENTIFIER = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_IDENTIFIER", + DefaultLanguageHighlighterColors.IDENTIFIER + ) + val NUMBER = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_NUMBER", + DefaultLanguageHighlighterColors.NUMBER + ) + val STRING = TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_STRING", + DefaultLanguageHighlighterColors.STRING + ) + val KEYWORD = + TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_KEYWORD", + DefaultLanguageHighlighterColors.KEYWORD + ) + val OPERATOR = + TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_OPERATOR", + DefaultLanguageHighlighterColors.OPERATION_SIGN + ) + val ASSIGNMENT_OPERATOR = + TextAttributesKey.createTextAttributesKey( + "TORQUESHADERLANGUAGE_ASSIGNMENT_OPERATOR", + DefaultLanguageHighlighterColors.OPERATION_SIGN + ) + val BAD_CHARACTER = + TextAttributesKey.createTextAttributesKey("TORQUESHADERLANGUAGE_BAD_CHARACTER", HighlighterColors.BAD_CHARACTER) +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/grammar/TorqueShaderLanguage.bnf b/src/org/lukasj/idea/torquescript/grammar/TorqueShaderLanguage.bnf new file mode 100644 index 0000000..f190e45 --- /dev/null +++ b/src/org/lukasj/idea/torquescript/grammar/TorqueShaderLanguage.bnf @@ -0,0 +1,199 @@ +{ + parserClass="org.lukasj.idea.torquescript.parser.TslParser" + + psiClassPrefix="Tsl" + psiImplClassSuffix="Impl" + psiPackage="org.lukasj.idea.torquescript.psi" + psiImplPackage="org.lukasj.idea.torquescript.psi.impl" + + elementTypeHolderClass="org.lukasj.idea.torquescript.psi.TslTypes" + elementTypeClass="org.lukasj.idea.torquescript.psi.TslElementType" + tokenTypeClass="org.lukasj.idea.torquescript.psi.TslTokenType" + + extends(".*Expression")=expression +} + +torqueshaderlanguageFile ::= TORQUESHADER IDENT LBRACE programGlobals RBRACE + +programGlobals ::= programGlobalList + +programGlobalList ::= structDecl programGlobalList? + | shaderStage programGlobalList? + +shaderStage ::= VERTEX_SHADER LBRACE shaderBody RBRACE + | PIXEL_SHADER LBRACE shaderBody RBRACE + | GEOMETRY_SHADER LBRACE shaderBody RBRACE + | COMPUTE_SHADER LBRACE shaderBody RBRACE + +shaderBody ::= statementList + +structDecl ::= STRUCT IDENT LBRACE structBodyList RBRACE + +structBodyList ::= structMember structBodyList? + +structMember ::= varType IDENT COLON structSemantic STMT_SEPARATOR + | varType IDENT STMT_SEPARATOR + | functionDef + +uniformDecl ::= UNIFORM varDecl + +staticConstDecl ::= STATIC varDecl + | STATIC CONST varDecl + | CONST varDecl + +varDecl ::= varType IDENT STMT_SEPARATOR + | varType IDENT ASSIGN expression STMT_SEPARATOR + | varType IDENT LBRACK expression RBRACK STMT_SEPARATOR + | varType IDENT LBRACK expression RBRACK ASSIGN LBRACE expressionList RBRACE STMT_SEPARATOR + | IDENT IDENT STMT_SEPARATOR + +paramModifier ::= IN + | OUT + | INOUT + +functionDef ::= varType IDENT LPAREN functionParamList RPAREN LBRACE statementList RBRACE + | varType IDENT LPAREN functionParamList RPAREN STMT_SEPARATOR + | IDENT IDENT LPAREN functionParamList RPAREN LBRACE statementList RBRACE + | IDENT IDENT LPAREN functionParamList RPAREN STMT_SEPARATOR + +functionParamList ::= functionParam (COMMA functionParamList)? + +functionParam ::= paramModifier varType IDENT + | varType IDENT + | IDENT IDENT + | paramModifier IDENT IDENT + +expressionList ::= expression + | expression COMMA expressionList + +expression ::= binaryExpression + | prefixUnaryExpression + | postfixUnaryExpression + | funcCallExpression + | parenExpression + | literalExpression + | identExpression + +literalExpression ::= LITERAL_INTEGER | LITERAL_FLOAT | LITERAL_DOUBLE | LITERAL_HEXDIGIT | TRUE | FALSE + +identExpression ::= IDENT +parenExpression ::= LPAREN expression RPAREN + +binaryExpression ::= expression (binaryOperator | assignOperator) expression +prefixUnaryExpression ::= expression (INCREMENT | DECREMENT | MEMBER_VAR) +postfixUnaryExpression ::= (NOT | MINUS | INCREMENT | DECREMENT) expression + +funcCallExpression ::= MULFUNC LPAREN expression COMMA expression RPAREN + | FRACFUNC LPAREN expression RPAREN + | LERPFUNC LPAREN expression COMMA expression COMMA expression RPAREN + | SAMPLEFUNC LPAREN expression COMMA expression RPAREN + | varType LPAREN expression RPAREN + | IDENT LPAREN expression RPAREN + +statementList ::= statement statementList? + +statement ::= varDecl + | uniformDecl + | staticConstDecl + | ifStatement + | whileStatement + | continueStatement + | breakStatement + | returnStatement + | functionDef + | expression STMT_SEPARATOR + | switchStatement + | discardStatement + | structDecl + | commentStatement + +ifStatement ::= IF LPAREN expression RPAREN LBRACE statementList RBRACE ELSE LBRACE statementList RBRACE + | IF LPAREN expression RPAREN LBRACE statementList RBRACE + +whileStatement ::= WHILE LPAREN expression RPAREN LBRACE statementList RBRACE + | DO LBRACE statementList RBRACE WHILE LPAREN expression RPAREN + +switchStatement ::= SWITCH LPAREN expression RPAREN LBRACE caseStatements RBRACE + +caseStatements ::= caseRule caseStatements? + +caseRule ::= CASE expression COLON statementList + | DEFAULT COLON statementList + +continueStatement ::= CONTINUE STMT_SEPARATOR + +breakStatement ::= BREAK STMT_SEPARATOR + +returnStatement ::= RETURN STMT_SEPARATOR + | RETURN expression STMT_SEPARATOR + +discardStatement ::= DISCARD STMT_SEPARATOR + +commentStatement ::= LINE_COMMENT | BLOCK_COMMENT + +varType ::= MAT3X4 + | MAT4X3 + | MAT3X3 + | MAT4X4 + | FVEC2 + | FVEC3 + | FVEC4 + | IVEC2 + | IVEC3 + | IVEC4 + | BVEC2 + | BVEC3 + | BVEC4 + | FLOAT + | INT + | UINT + | BOOL + | SAMPLER2D + | VOID + +structSemantic ::= SV_POSITION + | POSITION + | NORMAL + | BINORMAL + | TANGENT + | TANGENTW + | TEXCOORD + | COLOR + | TARGET + | SV_DEPTH + | SV_ISFRONTFACE + | TESSFACTOR + | PSIZE + +assignOperator ::= ASSIGN + | ADD_ASSIGN + | SUBTRACT_ASSIGN + | MULTIPLY_ASSIGN + | DIVIDE_ASSIGN + | MODULO_ASSIGN + | BIT_SHIFT_LEFT_ASSIGN + | BIT_SHIFT_RIGHT_ASSIGN + | BIT_AND_ASSIGN + | BIT_OR_ASSIGN + | BIT_XOR_ASSIGN + +private binaryOperator ::= BIT_NOT + | BIT_SHIFT_LEFT + | BIT_SHIFT_RIGHT + | BIT_AND + | BIT_OR + | BIT_XOR + | AND + | OR + | NOT + | EQUAL + | NOT_EQUAL + | GT_EQUAL + | GT + | LT_EQUAL + | LT + | PLUS + | MINUS + | MULTIPLY + | DIVIDE + | MODULO diff --git a/src/org/lukasj/idea/torquescript/grammar/TorqueShaderLanguage.flex b/src/org/lukasj/idea/torquescript/grammar/TorqueShaderLanguage.flex new file mode 100644 index 0000000..5c6502d --- /dev/null +++ b/src/org/lukasj/idea/torquescript/grammar/TorqueShaderLanguage.flex @@ -0,0 +1,193 @@ +package org.lukasj.idea.torquescript.lexer; + +import com.intellij.lexer.FlexLexer; +import com.intellij.psi.tree.IElementType; +import com.intellij.psi.TokenType; +import org.lukasj.idea.torquescript.psi.TslTypes; + +%% + +%class TslLexer +%implements FlexLexer +%unicode +%function advance +%type IElementType +%eof{ return; +%eof} + +DIGIT = [0-9] +INTEGER = {DIGIT}+ +DOUBLE = ({INTEGER}?\.{INTEGER})|({INTEGER}(\.{INTEGER})?[eE][+-]?{INTEGER}) +FLOAT = ({INTEGER}?\.{INTEGER})[fF] +LETTER = [A-Za-z_] +FILECHAR = [A-Za-z_\.] +IDTAIL = [A-Za-z0-9_] +VAR = {LETTER}{IDTAIL}* +ID = {LETTER}{IDTAIL}* +ILID = {DIGIT}{IDTAIL}* +SPACE = [ \t\v\f] +HEXDIGIT = [a-fA-F0-9] + +/* +BLUEPRINT = [bB][lL][uU][eE][pP][rR][iI][nN][tT] +POSITION = [pP][oO][sS][iI][tT][iI][oO][nN] +BINORMAL = [bB][iI][nN][oO][rR][mM][aA][lL] +NORMAL = [nN][oO][rR][mM][aA][lL] +COLOR = [cC][oO][lL][oO][rR] +SV_POSITION = [sS][vV]_[pP][oO][sS][iI][tT][iI][oO][nN] +SV_TARGET = [sS][vV]_[tT][aA][rR][gG][eE][tT] +SV_DEPTH = [sS][vV]_[dD][eE][pP][tT][hH] + +TEXCOORD = [tT][eE][xX][cC][oO][oO][rR][dD][0-9] + */ + +DOC_COMMENT_BLOCK = ("///"([^/\n\r][^\n\r]*)?[\n\r]+)+ +LINE_COMMENT = "//"[^\r\n]* +MULTILINE_COMMENT = "/*" ( ([^"*"]|[\r\n])* ("*"+ [^"*""/"] )? )* ("*" | "*"+"/")? + +ESCAPES = [abfnrtv]|c[rpo0-9] +STR = "\"" +STRING = {STR} (\\.|[^\"\\\n\r])* {STR}? + +%% + + { + {LINE_COMMENT} { return TslTypes.LINE_COMMENT; } + {MULTILINE_COMMENT} { return TslTypes.BLOCK_COMMENT; } +// ----- SEMANTICS START ----- + BINORMAL[0-9]* { return TslTypes.BINORMAL; } + NORMAL[0-9]* { return TslTypes.NORMAL; } + TANGENT[0-9]* { return TslTypes.TANGENT; } + TANGENTW[0-9]* { return TslTypes.TANGENTW; } + COLOR[0-9]* { return TslTypes.COLOR; } + TARGET[0-9]* { return TslTypes.TARGET; } + POSITION[0-9]* { return TslTypes.POSITION; } + SV_POSITION[0-9]* { return TslTypes.SV_POSITION; } + // SV_TARGET[0-9]* { return TslTypes.SV_TARGET; } + SV_DEPTH[0-9]* { return TslTypes.SV_DEPTH; } + SV_ISFRONTFACE { return TslTypes.SV_ISFRONTFACE; } + TEXCOORD[0-9]* { return TslTypes.TEXCOORD; } + PSIZE { return TslTypes.PSIZE; } + TESSFACTOR[0-9]* { return TslTypes.TESSFACTOR; } +// ----- SEMANTICS END ----- +// ----- INTRINSIC FUNCTIONS START ----- + Sample { return TslTypes.SAMPLEFUNC; } + mul { return TslTypes.MULFUNC; } + frac|fract { return TslTypes.FRACFUNC; } + lerp|mix { return TslTypes.LERPFUNC; } +// ----- INTRINSIC FUNCTIONS END ----- +// ----- KEYWORDS START ----- + TorqueShader { return TslTypes.TORQUESHADER; } + struct { return TslTypes.STRUCT; } + uniform { return TslTypes.UNIFORM; } + // cbuffer { return TslTypes.CBUFFER; } + VertexShader { return TslTypes.VERTEX_SHADER; } + PixelShader { return TslTypes.PIXEL_SHADER; } + GeometryShader { return TslTypes.GEOMETRY_SHADER; } + ComputeShader { return TslTypes.COMPUTE_SHADER; } + // DomainShader { return TslTypes.DOMAIN_SHADER; } + // HullShader { return TslTypes.HULL_SHADER; } + float3x4|mat3x4 { return TslTypes.MAT3X4; } + float4x3|mat4x3 { return TslTypes.MAT4X3; } + float3x3|mat3|mat3x3 { return TslTypes.MAT3X3; } + float4x4|mat4|mat4x4 { return TslTypes.MAT4X4; } + float2|vec2 { return TslTypes.FVEC2; } + float3|vec3 { return TslTypes.FVEC3; } + float4|vec4 { return TslTypes.FVEC4; } + int2|ivec2 { return TslTypes.IVEC2; } + int3|ivec3 { return TslTypes.IVEC3; } + int4|ivec4 { return TslTypes.IVEC4; } + bool2|bvec2 { return TslTypes.BVEC2; } + bool3|bvec3 { return TslTypes.BVEC3; } + bool4|bvec4 { return TslTypes.BVEC4; } + float { return TslTypes.FLOAT; } + int { return TslTypes.INT; } + uint { return TslTypes.UINT; } + bool { return TslTypes.BOOL; } + sampler2D { return TslTypes.SAMPLER2D; } + if { return TslTypes.IF; } + else { return TslTypes.ELSE; } + while { return TslTypes.WHILE; } + do { return TslTypes.DO; } + break { return TslTypes.BREAK; } + // for { return TslTypes.FOR; } + switch { return TslTypes.SWITCH; } + case { return TslTypes.CASE; } + default { return TslTypes.DEFAULT; } + continue { return TslTypes.CONTINUE; } + discard { return TslTypes.DISCARD; } + void { return TslTypes.VOID; } + static { return TslTypes.STATIC; } + const { return TslTypes.CONST; } + in { return TslTypes.IN; } + out { return TslTypes.OUT; } + inout { return TslTypes.INOUT; } + // typedef { return TslTypes.TYPEDEF; } + true { return TslTypes.TRUE; } + false { return TslTypes.FALSE; } + return { return TslTypes.RETURN; } + +// ----- KEYWORDS END ----- +// ----- PUNCTUATION START ----- + \( { return TslTypes.LPAREN; } + \) { return TslTypes.RPAREN; } + \{ { return TslTypes.LBRACE; } + \} { return TslTypes.RBRACE; } + \[ { return TslTypes.LBRACK; } + \] { return TslTypes.RBRACK; } + ; { return TslTypes.STMT_SEPARATOR; } +// ----- PUNCTUATION END ----- +// ----- ASSIGNMENTS START ----- + = { return TslTypes.ASSIGN; } + \+= { return TslTypes.ADD_ASSIGN; } + -= { return TslTypes.SUBTRACT_ASSIGN; } + \*= { return TslTypes.MULTIPLY_ASSIGN; } + \/= { return TslTypes.DIVIDE_ASSIGN; } + %= { return TslTypes.MODULO_ASSIGN; } + &= { return TslTypes.BIT_AND_ASSIGN; } + \^= { return TslTypes.BIT_XOR_ASSIGN; } + \|= { return TslTypes.BIT_OR_ASSIGN; } + \<\<= { return TslTypes.BIT_SHIFT_LEFT_ASSIGN; } + >>= { return TslTypes.BIT_SHIFT_RIGHT_ASSIGN; } +// ----- ASSIGNMENTS END ----- +// ----- OPERATORS START ----- + // \. { return TslTypes.DOT; } + , { return TslTypes.COMMA; } + == { return TslTypes.EQUAL; } + \!= { return TslTypes.NOT_EQUAL; } + >= { return TslTypes.GT_EQUAL; } + > { return TslTypes.GT; } + \<= { return TslTypes.LT_EQUAL; } + \< { return TslTypes.LT; } + && { return TslTypes.AND; } + \|\| { return TslTypes.OR; } + \! { return TslTypes.NOT; } + \<< { return TslTypes.BIT_SHIFT_LEFT; } + >> { return TslTypes.BIT_SHIFT_RIGHT; } + & { return TslTypes.BIT_AND; } + \| { return TslTypes.BIT_OR; } + \^ { return TslTypes.BIT_XOR; } + \~ { return TslTypes.BIT_NOT; } + \+ { return TslTypes.PLUS; } + - { return TslTypes.MINUS; } + \* { return TslTypes.MULTIPLY; } + \/ { return TslTypes.DIVIDE; } + % { return TslTypes.MODULO; } + -- { return TslTypes.DECREMENT; } + \+\+ { return TslTypes.INCREMENT; } + // \? { return TslTypes.QUESTION_MARK; } + : { return TslTypes.COLON; } +// ----- OPERATORS END ----- + {INTEGER} { return TslTypes.LITERAL_INTEGER; } + {FLOAT} { return TslTypes.LITERAL_FLOAT; } + {DOUBLE} { return TslTypes.LITERAL_DOUBLE; } + 0[xX]{HEXDIGIT}+ { return TslTypes.LITERAL_HEXDIGIT; } + \.{ID} { return TslTypes.MEMBER_VAR; } + {ID} { return TslTypes.IDENT; } + // {STRING} { return TslTypes.STRING; } + {ILID} { return TokenType.ERROR_ELEMENT; } +} + +([\r\n]|{SPACE})+ { yybegin(YYINITIAL); return TokenType.WHITE_SPACE; } + +[^] { return TokenType.BAD_CHARACTER; } \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/lexer/TslLexerAdapter.kt b/src/org/lukasj/idea/torquescript/lexer/TslLexerAdapter.kt new file mode 100644 index 0000000..abe2b42 --- /dev/null +++ b/src/org/lukasj/idea/torquescript/lexer/TslLexerAdapter.kt @@ -0,0 +1,6 @@ +package org.lukasj.idea.torquescript.lexer + +import com.intellij.lexer.FlexAdapter + +class TslLexerAdapter : FlexAdapter(TslLexer(null)) { +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/parser/TslParserDefinition.kt b/src/org/lukasj/idea/torquescript/parser/TslParserDefinition.kt new file mode 100644 index 0000000..22a34b5 --- /dev/null +++ b/src/org/lukasj/idea/torquescript/parser/TslParserDefinition.kt @@ -0,0 +1,84 @@ +package org.lukasj.idea.torquescript.parser + +import com.intellij.lang.ASTNode +import com.intellij.lang.ParserDefinition +import com.intellij.openapi.project.Project +import com.intellij.psi.FileViewProvider +import com.intellij.psi.PsiElement +import com.intellij.psi.PsiFile +import com.intellij.psi.TokenType +import com.intellij.psi.tree.IFileElementType +import com.intellij.psi.tree.TokenSet +import org.lukasj.idea.torquescript.TslLanguage +import org.lukasj.idea.torquescript.lexer.TslLexerAdapter +import org.lukasj.idea.torquescript.psi.TslTypes.* +import org.lukasj.idea.torquescript.psi.TslFile + +class TslParserDefinition : ParserDefinition { + + override fun createLexer(project: Project?) = TslLexerAdapter() + + override fun createParser(project: Project?) = TslParser() + + override fun getFileNodeType() = FILE + + override fun getCommentTokens() = COMMENTS + + override fun getStringLiteralElements(): TokenSet = TokenSet.EMPTY + + override fun createElement(node: ASTNode?): PsiElement = Factory.createElement(node) + + override fun createFile(viewProvider: FileViewProvider): PsiFile = TslFile(viewProvider) + + override fun spaceExistenceTypeBetweenTokens(left: ASTNode?, right: ASTNode?): ParserDefinition.SpaceRequirements = + ParserDefinition.SpaceRequirements.MAY + + companion object { + @JvmField + val WHITE_SPACES = TokenSet.create(TokenType.WHITE_SPACE) + + @JvmField + val COMMENTS = TokenSet.create(LINE_COMMENT) + + @JvmField + val FILE = IFileElementType(TslLanguage.INSTANCE) + + val KEYWORDS = TokenSet.create( + TORQUESHADER, STRUCT, UNIFORM, // CBUFFER, + VERTEX_SHADER, PIXEL_SHADER, GEOMETRY_SHADER, COMPUTE_SHADER, + MAT3X4, MAT4X3, MAT3X3, MAT4X4, + FVEC2, FVEC3, FVEC4, IVEC2, IVEC3, IVEC4, BVEC2, BVEC3, BVEC4, + FLOAT, INT, UINT, BOOL, SAMPLER2D, + IF, ELSE, WHILE, DO, BREAK, SWITCH, CASE, DEFAULT, CONTINUE, DISCARD, + VOID, STATIC, CONST, IN, OUT, INOUT, + RETURN, + ) + + val OPERATORS = TokenSet.create( + PLUS, MINUS, DIVIDE, MODULO, MULTIPLY, + AND, OR, NOT, + BIT_AND, BIT_OR, BIT_NOT, BIT_SHIFT_LEFT, BIT_SHIFT_RIGHT + ) + + val SEMANTICS = TokenSet.create( + BINORMAL, NORMAL, TANGENT, TANGENTW, COLOR, + TARGET, POSITION, SV_POSITION, SV_DEPTH, SV_ISFRONTFACE, + PSIZE, TESSFACTOR + ) + + val INTRINSICFUNCTIONS = TokenSet.create( + SAMPLEFUNC, MULFUNC, FRACFUNC, LERPFUNC + ) + + val ASSIGNMENT_OPERATORS = TokenSet.create( + ADD_ASSIGN, SUBTRACT_ASSIGN, DIVIDE_ASSIGN, MULTIPLY_ASSIGN, MODULO_ASSIGN, + BIT_AND_ASSIGN, BIT_OR_ASSIGN, BIT_XOR_ASSIGN, BIT_SHIFT_LEFT_ASSIGN, BIT_SHIFT_RIGHT_ASSIGN + ) + + val NUMBERS = TokenSet.create( + LITERAL_FLOAT, LITERAL_DOUBLE, LITERAL_INTEGER, LITERAL_HEXDIGIT + ) + + val BOOLEANS = TokenSet.create(TRUE, FALSE) + } +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/psi/TslElementType.kt b/src/org/lukasj/idea/torquescript/psi/TslElementType.kt new file mode 100644 index 0000000..209189e --- /dev/null +++ b/src/org/lukasj/idea/torquescript/psi/TslElementType.kt @@ -0,0 +1,8 @@ +package org.lukasj.idea.torquescript.psi + +import com.intellij.psi.tree.IElementType +import org.jetbrains.annotations.NonNls +import org.lukasj.idea.torquescript.TslLanguage + +class TslElementType(debugName: @NonNls String) : IElementType(debugName, TslLanguage.INSTANCE) { +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/psi/TslFile.kt b/src/org/lukasj/idea/torquescript/psi/TslFile.kt new file mode 100644 index 0000000..3304c89 --- /dev/null +++ b/src/org/lukasj/idea/torquescript/psi/TslFile.kt @@ -0,0 +1,17 @@ +package org.lukasj.idea.torquescript.psi + +import com.intellij.extapi.psi.PsiFileBase +import com.intellij.openapi.fileTypes.FileType +import com.intellij.psi.FileViewProvider +import org.lukasj.idea.torquescript.TslFileType +import org.lukasj.idea.torquescript.TslLanguage + +open class TslFile(viewProvider: FileViewProvider) : PsiFileBase(viewProvider, TslLanguage.INSTANCE) { + override fun getFileType(): FileType { + return TslFileType.INSTANCE + } + + override fun toString(): String { + return "Torque Shader Language File" + } +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/psi/TslTokenType.kt b/src/org/lukasj/idea/torquescript/psi/TslTokenType.kt new file mode 100644 index 0000000..3d518a5 --- /dev/null +++ b/src/org/lukasj/idea/torquescript/psi/TslTokenType.kt @@ -0,0 +1,10 @@ +package org.lukasj.idea.torquescript.psi + +import com.intellij.psi.tree.IElementType +import org.jetbrains.annotations.NonNls +import org.lukasj.idea.torquescript.TSLanguage +import org.lukasj.idea.torquescript.TslLanguage + +class TslTokenType(debugName: @NonNls String) : IElementType(debugName, TslLanguage.INSTANCE) { + override fun toString() = "TslTokenType." + super.toString() +} \ No newline at end of file diff --git a/src/org/lukasj/idea/torquescript/reference/TSFileReference.kt b/src/org/lukasj/idea/torquescript/reference/TSFileReference.kt index 78bb092..01df296 100644 --- a/src/org/lukasj/idea/torquescript/reference/TSFileReference.kt +++ b/src/org/lukasj/idea/torquescript/reference/TSFileReference.kt @@ -9,9 +9,6 @@ import com.intellij.psi.util.PsiTreeUtil import org.lukasj.idea.torquescript.TSFileUtil import org.lukasj.idea.torquescript.psi.TSLiteralExpression import org.lukasj.idea.torquescript.psi.impl.TSAssignmentExpressionImpl -import org.lukasj.idea.torquescript.psi.impl.TSLiteralExpressionElementImpl -import org.lukasj.idea.torquescript.taml.TamlModuleService -import java.io.File import java.nio.file.InvalidPathException class TSFileReference(literal: PsiElement, rangeInElement: TextRange, val isAssetPath: Boolean = false) :