ForTea.Core Performs some specific analysis that cannot be done through problem analyzers Base class for every T4 daemon stage. Gets the target framework ID. Gets the C# language version. Gets the default included assemblies. Gets whether the current environment is supported. VS2005 and VS2008 aren't. Gets the common include paths from the registry. The PSI file this translator is responsible for. It can be booth real T4 file and T4 file included into another one. The source file from which the is built. A factory for T4 composite elements. Creates a new statement block (<# ... #>). The code that will be contained in the block. A new instance of . Creates a new feature block (<#+ ... #>). The code that will be contained in the block. A new instance of . Creates a new directive (<#@ ... #>). Name of the directive. The directive attributes. A new instance of . Creates a new directive attribute. The name of the attribute. The value of the attribute. A new instance of . Lexer filtering whitespaces. Factory creating . Since the other ParseFile method is used in some external places, this method should not contain any additional logic This method builds PSI from scratch, which might cause creepy StackOverflowExceptions, difficult-to-catch bugs and performance issues! Use it VERY carefully! Represents a T4 token node type. Creates a new token having this token type. The buffer holding the token text. The token starting offset in . The token ending offset in . A new instance of . Gets the fixed string representation of the token type if available, otherwise. Gets whether the token type is a block tag. Gets whether the token type is a whitespace. Gets whether the token type is a comment. Always returns false. Gets whether the token type is a string literal. Gets whether the token type is a constant literal. Always returns false. Gets whether the token type is an identifier. Gets whether the token type is a keyword. Always returns false. Initializes a new instance of the class. The token type name. An unique index for this token node type. The static token type representation. The special type of token. This cache stores the T4 file include dependency graph and manages dependent file invalidation: whenever a file is marked as dirty and its include list changes, this cache marks all the former dependencies and all the new dependencies as dirty. whether an includer was added in a cache entry for some include Note that a marshaller for does not exist. That class is not intended to be persisted PSI for T4 files might depend on other T4 files. To keep it up-to-date, we need to mark a file as dirty whenever anything it depends on is changed in any way. Perform a breadth-first search for a sink. Since the graph is not guaranteed to contain no cycles, it also checks that there are no includes. If there are no potential sinks (if, for example, the source is a sink itself, or there are only loops in hierarchy), returns source. Performs DFS to collect all the files that include the current one, avoiding loops in includes if necessary T4 files that are included into preprocessed files should be handled differently from the ones that are not. However, that knowledge is required during PSI module construction, and on that stage there's no guarantee of caches being ready. Therefore, we store this information directly in project files. This class is isomorphic to , but is kept separate to avoid confusing lists of includes with lists of includers This is used for building correct PSI for .ttinclude files. T4 includes are similar to C++ ones, and symbols used in them can be defined in other .ttinclude files. It is only possible to track this by choosing the most complete context for each file, i.e. the uppermost file that includes the current one. TODO: cache root? Represents the difference between two . Gets an enumeration of all added assemblies. Gets an enumeration of all removed assemblies. Computes a difference between this data and another one. The old data. An instance of containing the difference between the two data, or null if there are no differences. Cache holding for each T4 file. It cannot be implemented like ordinary cache because it needs PSI to build. Called when a PSI file is created. The file that was created. Called when a PSI element changes. The tree node that changed. The type of the PSI change. The type of part built on the background The result of handling the request on the main thread Contains information about supported T4 directives. Gets information about the template directive. Gets information about the parameter directive. Gets information about the output directive. Gets information about the include directive. Gets information about the assembly directive. Gets information about the import directive. Gets a collection of all known directives. Order of elements in this collection will be used to order the directives. Represents a T4 project file type. Gets an unique instance of . Gets the name of the file type. Whether a change was made PSI module managing a single T4 file. Called when the associated data file changed: added/removed assemblies or includes. The difference between the old and new data. Provides for T4 files opened outside of the solution. Provides for T4 files opened inside the solution. Provides a for a given project. Manages for T4 files. Contains common implementation for and . Gets all s for opened files. A collection of . Gets all source files for a given project file. The project file whose source files will be returned. Processes changes for specific project file and sets up a list of corresponding source file changes. The project file. Type of the change. The change builder used to populate changes. if further changing is required, null otherwise An implementation of that creates occurrences for find results that are inside included files that aren't present in the current solution, and thus ignored by ReSharper. Represents an occurence of text in an include file that is located outside of the solution. A component that manages s for files outside the solution. assemblyName is assumed to NOT contain macros In T4, it's typical to include file from outside of solution. Such files are managed by and lack project file. For such files we create context that contains the most suitable project file to be used for macro resolution Base, file independent language service for T4. Creates a lexer that filters tokens that have no meaning. The base lexer. An implementation of a filtering lexer. Gets a factory capable of creating T4 lexers. An implementation of . Creates a parser for a given PSI source file. The lexer that the parser will use. The module owning the source file. The source file. A T4 parser that operates onto . For the sake of providing the most complete intelligent support, we make the widest possible context part of the primary PSI. Gets a cache provider for T4 files. TODO: implement a cache provider Gets a type presenter. Language service for T4 project files. Gets the PSI language type, . Gets the T4 file icon. Initializes a new instance of the class. Type of the T4 project file. The host environment. C# custom modification handler that allows the T4 files to be modified in response to C# actions or quickfixes. (eg: adding a using statement translates to an import directive). Determines whether namespace aliases can be used. Always false since T4 files does not support aliases. Determines whether static imports can be used. Always false since T4 files does not support static imports. Creates a new T4 code block. The C# code. Where to insert the code. A new instance of . Gets the code tree text range of a code block. The code block. A representing the code range in . Creates a T4 import directive instead of a C# using directive. true to create the directive before ; false to create it after. An existing directive serving as an anchor for the new directive. The C# using directive. The original T4 file where the directive must be created. A corresponding to the namespace in the newly created directive. Gets the text range of a C# using directive namespace. The using directive. A corresponding to the namespace in . Removes an import directive. The original T4 file where the directive must be removed. The import directive in the file. Creates a new feature block with new type members. The original T4 file where the feature block must be created. The code representing new C# type members. The first node. The last node. A representing the code range in the newly created feature block. Creates a new line token. The associated PSI module. A T4 new line token. Gets an existing feature block that can contains type members. The original T4 file. A valid if a feature block existed, otherwise. Determines whether a specified C# using directive can be removed. The document. The using directive. true if the specified using directive can be removed; otherwise, false. As long as the using is represented as a T4 import directive in the root file, it can be removed. Handles the removal of an import directive. The PSI services. The namespace scope. The using directive to remove. The action to perform to remove the directive. Handles the removal of a type member from a code block. The PSI services. The node that must be removed. The action to execute to remove the node. Gets the body of a method that is visible for user. The method. Always the body of . Retrieves the namespace from a C# using directive. The using directive. The namespace contained in . Handles the addition of an import directive. The PSI services. The action to perform to add the directive. The existing using anchor. Whether to add the statements before of after . The generated file. An instance of . Initializes a new instance of the class. The language manager. This class will generate a C# code-behind from a T4 file. Generates a C# file from a T4 file. The modifications that occurred in the T4 file. Gets the secondary PSI language types for a T4 file. Always . Creates a secondary lexing service for code behind generated files. The solution. The mixed lexer. The source file. An instance of used to lex the code behind file. Gets a lexer factory capable of handling preprocessor directives. The primary language. Always null since there is no preprocessor directives in T4 files. Reparses the original T4 file. The tree text range to reparse. The new text to add at . The range translator. true if reparse succeeded, false otherwise. The process of generated document commit (in the case of primary document incremental reparse) can be overridden in this method. Returns null if full regeneration is required. This method is not allowed to do destructive changes due to interruptibility! Represents the T4 language. Gets the name of the T4 language. Gets an unique instance of . Module referencer that adds an assembly directive to a T4 file. Indicates if this file should be parsed. Secondary lexing process for T4 files, capable of getting a lexer for the code behind file. Tries to create a lexer for a code behind file. The base T4 lexer. A C# lexer for the current code block, or null if none could be created. Determines whether this instance can handle the specified project file type. Type of the project file. true if this instance can handle the specified project file type; otherwise, false. Initializes a new instance of the class. The code behind language. The mixed lexer. Contains extension methods for code completion. We can't inherit from CSharpCodeStructureAspect since it's internal, so we have to duplicate a bit of functionality from R# here. We can't inherit from CSharpCodeStructureDeclaredElement since it's internal, so we have to duplicate a bit of functionality from R# here. Support for extend selection (Ctrl+W). Typing assistant for C# embedded in T4 files. When = is typed, insert "". When a # is typed, complete code block If a feature block is followed by newlines, they get ignored, see . This state represents that newlines should not be ignored anymore because there is an expression block after a feature block All newlines that appear after a feature block should be ignored, no matter how many of them there are. After any non-newline token, however, newlines should once again be taken into account If a feature block is followed by newlines, they get ignored, see . This state represents that newlines should not be ignored anymore because there is text after a feature block Generates code that will be placed directly in the user solution (or used to provide editing support for a template that would do that) Generates code that will be executed (or used to provide editing support for a template that would do that) This class generates a code-behind text from C# embedded statements and directives in the T4 file. That text is used for providing code highlighting and other code insights in T4 source file. That code is not intended to be compiled and run. TODO: replace with standard implementation Holds a generated result for code-behind generation. Gets the string builder containing the generated text. Gets the generated range map. Appends a mapped text. The text to add. The original text range. Appends a mapped node. The tree node to add. Appends another to this result. The other result to append. Creates a new instance of for a given file. The T4 file that will be used for code-behind generation. Target extension. Leading dot, if any, is removed. Returns null if the file does not contain 'output' directive with 'extension' attribute. The base class that contains mostly boilerplate code. I'll try to find a way to remove it Implementation of . Gets the node type of this element. Checks if this element is filtered (whitespace, comment or error). Returns a textual representation of the token. A textual representation of the token. Initializes a new instance of the class. The token type. The buffer holding the token text. The token starting offset in . The token ending offset in . Primary PSI for a T4 file contains a lot of context, including the files that include the current T4 file and indirect includes. This is done in order to provide the most complete intelligent support. This means that PSI now doesn't just contain contents of the source file it corresponds to, but also a bunch of other files. is a reference to the file that was the source of tokens for the current . Which source file caused the current tree of T4 files to be built. Note that within the same tree there can be multiple nodes with different but all of them share the same Contract representing a T4 token node. Contract representing a T4 tree node. Gets a T4 block containing a specified C# node. The type of expected T4 container node. The C# node whose T4 container will be retrieved. An instance of , or null if no container for can be found. Some nodes in T4 tree constitute include context. Here I'll call them invisible Same as , but works during secondary PSI generation T4 Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected. jVVVVVVVVVVVVVVVVVVj ~P* ^P* 1X_....` `.....tX|6666666 22222k67```.hU2225P6a=:::;wn }w"```!wr ;kXL,::::}b~ `bP....ob'"ab7",/",,^HX *qc---^qV2A1;"\En"""7R|` XR":::s##j!^;Iww/^^^kw## _#j:::,dDR;~~~~~~~~~~~!Dw {Dr___LD8Aooooooc;;;loX8r `Dm~^^^h8c;;;;;88*;;=88;;` *88888884 ~MMMMMMMs For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:DaqipexThemedIconsThemedIcons+T4}" /> <!-- XAML --> [Item(Name="Sample", Icon=typeof(DaqipexThemedIconsThemedIcons.T4))] // C# Type attribute IconId iconid = DaqipexThemedIconsThemedIcons.T4.Id; // IconId identifier object themediconmanager.GetIcon<DaqipexThemedIconsThemedIcons.T4>() // Icon image for rendering identifier class Loads the image for Themed Icon T4 theme aspect Color. Loads the image for Themed Icon T4 theme aspect Gray. Loads the image for Themed Icon T4 theme aspect GrayDark. Returns the set of theme images for Themed Icon T4. T4Entity Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected. cVVVVVVVVVVVVVJ 3E` -EEe ~E= `Uj ;UU7 |U, 7XXXX|```JXX!```aXXXX= hX`````````````````l4: -we___.``-__,```-___6w` _[[fb4-..=bbn...|b3[[) *]]ndI---7dd(---jd2]]; 6O!;;"---^;;,---;;;2O^ .m6:::::::::::::::::4m` ;#####^,,*##4,,,J####X -Dw"""FDDC"""kD_ ;83^^^488)^^~D8` s8888888888888h For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:FybabunThemedIconsThemedIcons+T4Entity}" /> <!-- XAML --> [Item(Name="Sample", Icon=typeof(FybabunThemedIconsThemedIcons.T4Entity))] // C# Type attribute IconId iconid = FybabunThemedIconsThemedIcons.T4Entity.Id; // IconId identifier object themediconmanager.GetIcon<FybabunThemedIconsThemedIcons.T4Entity>() // Icon image for rendering identifier class Loads the image for Themed Icon T4Entity theme aspect Color. Loads the image for Themed Icon T4Entity theme aspect Gray. Loads the image for Themed Icon T4Entity theme aspect GrayDark. Returns the set of theme images for Themed Icon T4Entity.