Version History

Fixed a possible exception when parsing invalid documentation comments, and also improved parsing of such comments.

Fixed determination of the iteration type in foreach loops for IEnumerables with multiple GetEnumerator() methods.

Fixed to relax 'ref' matching on imported COM interface method parameters in dependent DLLs.

Fixed check for Optional attribute on parameter declarations (for source code - metadata was ok). This was not really an issue since it was also checking for any initialization to mean it was optional).

Fixed to treat the conversion of a Literal as 'better' to a primitive integral type vs a pointer type when trying to choose a better method match.

Fixed NamedCodeObjectDictionary/NamedObjectDictionary.Remove() to leave the correct object in the dictionary when removal reduces a collection of two objects overloaded on the same name to a single object remaining.

Improved filtering of duplicate matches to treat generic array parameter types as more specific if they have more array ranks (such as T[][] where T is 'int' is more specific than T[] where T is 'int[]').

Added relaxed ref/out matching for parameters of methods in types with a "ComImport" attribute (the 'ref' keyword is not required by C# for 'ref' parameters of imported COM methods, since they tend to have many parameters, most with 'ref').

Fixed setting of individual modifiers on Local/FieldDecls (IsConst, IsPublic, etc) to throw an exception if the parent is a MultiLocal/FieldDecl, and also the Add() method of MultiLocal/FieldDecl to bypass such validation when forcing the modifiers of the added Local/FieldDecl to match those of the Multi.

Fixed setting of Modifiers on MultiLocalDecl/MultiFieldDecl/MultiFixedSizeBufferDecl to bypass exception checking in child instances.

Fixed a problem with the handling of newlines in the expressions inside interpolated strings.

Fixed a type argument evaluation issue for assignments in initializers.

Fixed type evaluation of pointer indirection operator for pointer counts greater than 1.

Fixed to properly deep-clone expressions within interpolated string literals.

Fixed to handle VARIANT types from IDL-generated DLLs as 'dynamic', via DispIdAttribute.

Fixed the return type of lambdas with an assignment body to be 'void'.

Rolled back Literal.ProcessEscapeSequences() change.

Changed TypeRef.GetFullName() to include any array ranks on Mono TypeReference types.

Fixed an issue in Literal.ProcessEscapeSequences().

Fixed an issue with internal extension methods being treated as accessible in other assemblies.

Fixed a problem parsing fields with tuple types properly if proceeded with annotations.

Fixed to ignore case for 'exists' in Project conditional expressions.

Changed TypeRef.GetFullName() to include any array ranks on types.

Improvements to handling of comments on lambda-bodied declarations.

Improvements to loading of project references.

C# 7.3: Improved method resolution when arguments differ by 'in' (prefer 'in' if argument is 'in', otherwise prefer NOT 'in').

C# 7.2: Added support for delegates with ref and/or readonly return types.

C# 7.2: Fixed rendering order for 'private protected' access modifier and 'readonly ref' structs.

Made some static initialization methods synchronized to avoid possible re-entrancy problems.

Changed generated internal names for Adder/RemoverDecl to use a single underscore.

C# 7.3: Expression variables in initializers and queries.

C# 7.3: Stackalloc initializers.

C# 7.3: 'unmanaged' generic type constraint (also System.Enum and System.Delegate - no changes required).

C# 7.3: Ref local re-assignment: Ref locals and parameters can be reassigned with ' = ref '. (no changes required)

C# 7.3: Tuple comparison: Tuples can now be compared with '==' and '!='. (no changes required)

C# 7.3: Attributes on backing fields: Can use '[field: ...]' attributes on an auto-implemented property to target its backing field. (no changes required)

C# 7.3: Indexing movable fixed buffers: Fixed buffers can be indexed into without first being pinned. (no changes required)

C# 7.3: Custom fixed statement: Types that implement a GetPinnableReference() method can be used in a fixed statement. (no changes required)

Fixed a problem with local functions interfering with the calculated return type of lambda/anonymous methods.

Changed precedence of 'as' and 'is' operators from relational to additive group (all C# documentation is wrong).

Fixed an issue with processing of escape sequences by Literal.Value.

Added support for evaluated types of initializers that are arrays of delegate types.

Added support for compiler directives inside empty parameter lists.

Rendering fixes for Nova Studio related to compiler directives around list members and inside empty parameter lists.

Fixed a parsing issue for methods with tuple return types (C# 7).

Fixed to resolve Out/LocalDeclExprs in switch/for/foreach/lock target expressions (C# 7).

Fixed an issue with parameter matching of lambdas with 'default' return value (C# 7.1).

Fixed issues with parsing of conditional directives around parameter declarations, arguments, and sub-expressions.

Fixed MethodDeclBase.IsLocalFunction to work properly when nested in a lambda.

Changed Literal.Value property to return the raw text property if it can't be parsed into a valid object, primarily so that it returns the fragments of interpolated strings even though they're not valid C# literals.

Fix to previous change to handle forward references to local functions so that local functions inside lambdas are resolved properly.

Fixed to handle references to named indexers in external (COM) libraries (not legal in C# sources).

C# 7.2: Non-trailing named arguments.

C# 7.2: Reference semantics with value types: 'in' modifier on parameters (already supported 'ref readonly' return values and 'ref' and/or 'readonly' structs).

C# 7.2: Ref Conditional operator (already supported).

C# 7.2: 'private protected' access (already supported).

C# 7.2: Leading separator in numeric literals (already supported).

Added support for implicit conversions between tuples with types that have implicit conversions.

Improved to take 'out'/'ref' status into account when matching method parameters.

Fixed a parsing issue with '?' inside code comments related to '?.' support.

Fixed to handle forward references of local functions (nested methods).

Improved support for new format project files.

Fixed to not reference 'mscorlib' if the NoStandardLibraries tag is 'true' in the project file (in addition to 'NoStdLib' in a Configuration section).

Fixed a bug in Block.Insert() if a Block is passed in that could insert it at the wrong location.

Fixed to infer the type properly when new 'default' usage is on the right side of a binary operator like '=='.

Added support for .NET Core C# project type GUID.

Added support for parsing of project.assets.json file to determine package reference paths.

Fixed parsing of decimal literals containing underscores.

Fixed a problem parsing Deconstructions as ForEach loop variables when they don't have a shared type, and also if there are unused tokens in the stream (including comments).

Fixed a parsing issue with LocalDeclExprs inside LINQ statements in certain scenarios.

Fixed parsing of package references in project files to handle Version as a body element in addition to an attribute.

Fixed a parsing issue with switch cases having a 'when' clause in some scenarios that conflict with local variable expression parsing.

Fixed to prevent implicit conversions of the If expression of Conditionals.

Fixed Literal.DetermineValue() to properly handle binary constants and underscores.

Added support for nested Deconstructions, and improved handling of 'shared' var types.

Added support for Deconstruct() extension methods, added a HiddenRef to Deconstruction for any Deconstruct() method used, and added support for matching the parameter count of such methods when resolving uses of them.

Added support for adding LocalDeclExpr symbols in a 'using' expression to the parent scope.

Added support for 'ref' on the return type of delegate declarations.

Improvement to MethodDeclBase.IsLocalFunction property.

C# 7.1: Default literal expression support.

C# 7.1: Inferred tuple element name support (supported since 7.2).

C# 7.1: Async main support (always supported).

Changed ThrowExpr to return a null type (which is implicitly convertible to any other type).

Fixed unresolving to skip nullable built-in types.

Fixed a problem with parsing of NullSafeIndex ('?[') due do Conditional taking precedence.

Fixed an issue resolving overridden methods with lambda parameters if named arguments were used.

Fixed an issue with tuples incorrectly indicating that they had an unresolved field type in certain scenarios.

Fixed a problem resolving methods in base interfaces when the same method is found via different paths through the base interfaces (meaning the same interface appears more than once) and type arguments are involved and resolve to different types on the different paths.

Added support for 'when' clauses on any (not just pattern-matching) 'case' statements.

Added support for nested deconstruction expressions, and fixed them to evaluate to the tuple type they effectively represent including inferred element names.

Added support for 'ItemN' fields on tuples where N is 8 or greater.

Added caching to type evaluations to fix a performance problem with long chains of method calls (15+) involving generic types and type arguments on the far left of the chain.

Fixed a possible null reference exception if trying to choose a best matching method and one of the arguments is a DiscardRef.

Fixed a possible null reference exception evaluating type arguments in tuples if one of the tuple arguments is a DiscardRef.

Fixed parsing of OutLocalDeclExprs with a generic type.

Fixed the scope of local variable expressions in 'for' conditional expressions, and fixed a couple of issues with such variables not being found at the parent block scope.

Fixed the scope of pattern matching variables in 'for' conditional expressions.

Fixed TupleRef to have the proper underlying ValueTuple in some scenarios.

Fixes for the proper evaluation of the 'var' of a shared-type Deconstruction, and also of the types of the embedded LocalDecls when referenced elsewhere.

Fixed to set the line/column numbers of Deconstruction and the embedded LocalDecls.

Fixed an issue with operator overloads and interpolated strings due to special IFormattable implicit conversions.

Fixed analysis to visit any child list of expressions in interpolated strings.

Fixed the LocalDeclExpr and OutLocalDeclExpr constructors to be public, to allow for manual code construction.

Fixed a problem with Conditional correctly evaluating to one of the two types when small constants are involved (such as an 'int' value of 32 converting to a 'byte').

Fixed an issue with '(int)' being considered a tuple by the peek-ahead parsing logic by requiring tuples to have more than 1 argument.

Fixed FieldRef.GetDeclaringType() to return any parent TupleRef.

Fixed MethodDeclBase.DeclaringType to skip over any parent methods and return the parent TypeDecl.

Added caching to type evaluations to fix a performance problem with long chains of method calls involving generic types and type arguments on the far left of the chain.

Added support for 'out TYPE _' style out parameter discards, and also the matching of the more typical 'out _' style discard arguments to any parameter type when resolving method references.

Added support for 'var' types in switch/case pattern matching expressions.

Added support for deconstruction in the iteration of for-each loops.

Fixed scope of pattern matching local variables in switch/case to be restricted to only the individual case.

Fixed resolving of parameter types for local functions (nested methods) inside constructors.

Fixed resolving of default property values.

Fixed parsing of '(this.Field)++;'.

Fixed referencing protected overridden methods from within a base class.

Fixed to allow a shared 'var' type for a Deconstruction with each local variable evaluating to it's own type.

C# 7: Out variable support (new OutLocalDeclExpr class).

C# 7: Pattern matching support (new LocalDeclExpr class, conditional Case support).

C# 7: Ref locals and returns support.

C# 7: Tuples and Deconstruction support (new TupleRef, NewTuple, Deconstruction, DeconstructionExpr classes).

C# 7: Throw expression support (new ThrowExpr class).

C# 7: Local functions (nested methods) support.

C# 7: Discard variable support (new DiscardRef, DiscardDecl classes).

C# 7: Binary literals and numeric literal digit separator support.

C# 7: Expression-bodies for constructors, finalizers, and property get/set.

C# 7: Generalized async return type support.

Fixed an issue with type evaluation of '??' due to an error in the C# specification.

Improved handling of new-format VS2017 project files (support for new C# project type GUID, and new PackageReference/DotNetCliToolReference classes).

Improvements for finding VSSDK assemblies, including for VS2017.

Fixed a parse issue if '?.' is followed by a numeric constant (and so is really a '?').

Fixed searching for a type argument in the left side of a Dot operator where the left expression is of a nested type to check any base generic type before checking any parent types.

Improved support for new VS 2017 project and solution files.

Fixed to support implicit conversions of interpolated strings to types which implement IFormattable (which was itself already supported).

Fix for parsing a complex conditional expression containing compiler directives.

Added a check for a null ref that could occur in invalid code.

Improved support for handling parsing of invalid code.

Added Start Line/Col support for TypeDecls (position of first modifier vs main keyword).

Started support for building a .NET Standard targeted version. Removed reliance of Metrics on System.ComponentModel.DescriptionAttribute.

Added support for building a .NET 3.5 targeted version.

Fixed an issue with parsing of parenthesized expressions versus casts within LINQ expressions.

Added support for modreq/modopt modifiers on the types of method parameters in external metadata.

Improved logic that determines the location of the Mono libraries for the Mono version.

Added support for NuGet style (JSON) project dependencies, and DNXCore dependencies for .NETPortable projects.

Added support for .NETCore 5.0 framework reference assemblies, NuGet style (JSON) dependencies, and individual folders.

Added support for TargetPlatformVersion/MinVersion and BaseIntermediateOutputPath in project files.

Improved support for API calls using project file macros, and added preliminary support for local properties.

Modified Nova Studio to be Large Address aware so it can use more than 1.3GB of memory with a 32-bit build.

Fixed an issue finding the better matching method when one has params and both have unused optional parameters.

Added special handling for '.' member lookups on the result of a call involving a '?.' operator.

Fixed an issue with the evaluation of the inferred types of 'from' clauses after the first one.

Fixed an issue in TypeDefinitionUtil.FindTypeParameterIndex(), so it works identically to the TypeUtil version.

Added null ref checks to GACUtil.CompareVersions().

Improved TypeParameterRef.IsSameRef() to return true for type parameters of overridden generic methods even if the name differs from the equivalent one in the base method. Also improved TypeParameter.ResolveRef() to evaluate any type parameter constraint in the current scope before resolving a member on it.

Added PropertyDefinitionUtil.IsIndexed(), changed all code to use it instead of HasParameters, and improved IsIndexed() on both metadata types to ignore any property parameters if they are optional.

Improved FromClause to fallback to a Where() method for evaluation if no Select() method exists.

Improved to ignore lambdas with undetermined inferred parameter types when determining the type of an initializer list, and improved TypeRef.GetCommonType() to allow MethodRefs to be treated as common with generic Func types.

Relaxed extension method lookups to not require that class be sealed (might not be in other languages or IL code).

Added support for matching overridden methods where a 'params' parameter in the base method declaration is not specified as 'params' in the override.

Fixed a problem with correctly finding all other parts of partial types in certain scenarios involving nested generic types.

Fixed to handle a reference to a internal member of an external reference to a type, where the type is actually declared in the current project.

Fixed to translate any Mono/Reflection global namespace of "" on a type to "global".

Fixed 'goto case' matching to handle a constant for the switch expression.

Fixed to handle an operator overload method in an outer class with the same name.

Fixed an issue with resolving attributes in a specific scenario where an alias is used.

Fixed to prefer non-dynamic types when resolving overloaded methods.

Fixed to load SDK files from any hint path over their default locations.

Fixed the ChildList indexer setter to check that the parent of the replaced object is set properly.

Fixed some issues with properly resolving the implicit Add method calls for collection initializers.

Fixed a problem resolving attributes on parameter declarations of delegate and indexer declarations.

Fixed an issue where moving attributes between code objects could result in attributes with a null parent link.

Fixed an issue matching overrides of methods with parameters having a type parameter type.

Fixed problems determining the correct parent expression for resolving implicit indexers inside initializers.

Fixed events declared as multi-field declarations in interfaces to correctly default to public access.

Fixed to convert a non-nullable value type return value from a method called on a '?.' expression into a nullable type.

Fixed to skip type argument matching for references passed to a 'nameof' operator.

Fixed a problem matching extension methods in 'using static' types.

Fixed an issue with variables of 'var' type that evaluate to 'dynamic' and are invoked as delegates.

Fixed a problem with output type inferencing involving arrays.

Fixed Literal.GetFormatString() to process escape sequences, or NOT if an optional bool parameter is passed.

Fixed a cast to 'dynamic' to properly evaluate as 'dynamic' instead of 'object' type.

Fixed an issue matching lambdas with object parameters with delegates with parameters of dynamic type.

Added support for C#'s unique overloading of And/Or operators using BitwiseAnd/BitwiseOr (and True/False).

Corrected the precedence of the 'await' operator.

Added handling of 'goto case null'.

Fixed an issue with the caching of extension methods added in the last release that could cause resolve errors.

Fixed a problem with the proper evaluation of nested conditional compilation directives.

Fixed a resolve issue involving a method group with a generic return type passed to a generic method with inferred type arguments.

Fixed a resolve issue involving proper type inference when a 'null' literal and lambdas are involved.

Added support for conditional compiler directives around the header of a property declaration.

Added handling of '@' prefix on constructor names (to support a sloppy code generator).

Added GetFormatString()/GetFormatArguments() methods to Literal for interpolated strings.

Possible BREAKING change: Split new NamedObjectDictionary/NamedObjectGroup out from existing NamedCodeObjectDictionary/NamedCodeObjectGroup classes - the first can hold metadata (IMemberDefinition/MemberInfo) objects, while the second is now restricted to INamedCodeObjects. Client code making use of NamedCodeObjectGroup should be changed to use NamedObjectGroup instead if compile errors occur. This change was made to support part of the implementation of the caching of extension method lookups for better performance (see below).

Fixed a resolving problem involving delegate fields in base classes with inferred type arguments.

Added support for InternalsVisibleTo assembly attributes that require resolving of the entire containing code unit in order to evaluate the string constant parameter (due to references to constant strings declared later in the file).

Performance: Removed all uses of HasFlag() for up to 10% better performance.

Performance: Added caching of extension method lookups on namespaces for up to 33% better performance on very large projects with heavy use of extension methods (minor or insignificant difference on smaller projects or with little extension method use).

Performance: Added caching of other parts of partial types for a significant performance improvement when there are a lot of partial types. The cached lists of other parts are reset for all parts when any TypeDecl is added/removed to/from a parent NamespaceDecl or TypeDecl.

Performance: Improved handling of messages by Solution and CodeUnit, for much better performance on projects with very large numbers of messages (such as errors).

UI Performance: Improved performance of very large numbers of messages (such as errors) in the UI.

Added support for implicit conversion of Literal interpolated strings to parameters of type IFormattable (C# 6.0).

Fixed line/col info for expression objects parsed from interpolated strings.

Added UI support in Nova Studio for expression objects parsed from interpolated strings.

Fixed a crash in Mono Cecil if the header of a loaded DLL has an empty version string.

Added support for lambda expression syntax for operator and indexer declarations (C# 6.0).

Updated PropertyDecl.IsAutomatic to work correctly for read-only or write-only automatic properties (C# 6.0).

Added parsing of expressions embedded in interpolated string literals (C# 6.0).

Added Literal.Value cached property (replaces Literal.GetValue()), and IsString/IsChar/IsNumeric/IsBool/IsInt, etc properties.

Added Index.FindTypeArgument() to allow IndexerRef.EvaluateType() to revert to the default behavior of evaluating any type arguments without causing any recursion problems.

Added Project.AddExistingFile() method, and fixed an issue with Solution correctly saving the relative paths of Project files in the '.sln' file.

Fixed formatting issues for lambda expressions used to initialize methods/properties in lambda expression format.

Fixed an issue with parsing nested Conditionals involving nullable types and an As operator.

Fixed an issue parsing generic method references with no arguments if parenthesized like a cast.

Fixed a problem parsing methods with the name 'async' due to lambda parsing logic.

Fixed problem handling 'await' or 'nameof' as identifiers in certain contexts.

Fixed Index.EvaluateType() to properly handle a null expression, which occurs for index initializers.

Improved parsing of unrecognized pragmas.

C# 6.0: Added support for Index Initializers.

Improved to only load interop types from referenced assemblies if the Embed Interop Types flag is True, and also further improved support for Type Equivalence for embedded interop types.

Fixed text rendering of null-safe index operator.

Fixed initializers to properly handle 'null' literals when evaluating the common type.

Fixed to not load types from referenced shared projects since the source files are included directly.

Fixed some resolving problems when passing lambdas as named arguments.

Fixed a resolving issue involving method references passed as named arguments that was resulting in a warning instead of an error.

Increased the version to 6.0 to reflect full C# 6.0 compatiblity.

Added support for Type Equivalence for embedded interop types.

Added support for defaulted configuration properties in project files (mainly for define constants), and a missing MSBuild macro.

Improved resolving members of types from referenced Profile projects.

Improved unresolved refs to not log warnings or errors in the case of valid usages of method groups, such as by the C# 6.0 'nameof' operator or in document comments.

Fixed a problem using the incorrect target framework version in some cases.

Fixed the NullSafeDot operator to evaluate to a Nullable type when appropriate, and fixed resolving of members where the "?." operator and nullable types are involved.

Fixed a problem parsing nested interpolated strings.

Fixed a couple of issues resolving lambdas in array initializers.

Fixed an access problem with internals in shared projects.

Fixed a problem resolving overloads when named arguments are used.

Fixed an issue with determining the proper return type of async lambdas.

Fixed problems inferring lambda parameters if used in a Conditional and passed to a method or used in a variable initializer.

Added filtering of abstract methods from multiple exact matches (can occur with generic methods with similarly constrained type arguments).

Fixed a resolving issue involving methods passed as named arguments.

C# 6.0: Added support for the null-safe index operator.

Added support for project-level define constants.

Added some null ref checks related to macro evaluation changes in v5.60.

Changed TypeParameterRef.CheckTypeConstraints() to NOT treat a 'class' constraint as equivalent to 'object'.

Fixed to dereference the left expression of the '?.' operator when evaluating if it's a nullable type.

C# 6.0: Added initial support for string interpolation ('$' prefix), including interpolated verbatim strings.

C# 6.0: Added support for new 'when' keyword (instead of 'if') for Exception Filters.

C# 6.0: Added support for new 'static' keyword for Using Static.

Added support for shared projects ('.shproj').

Fixed the license logic to parse the date in the license using the invariant culture.

Fixed a possible stack overflow in Await.EvaluateType().

Corrected the precedence of the lambda operator to be higher than the conditional operator.

Improved support for macro evaluation (including string method calls), and imported build files.

Changed the default file encoding to Windows-1252 if there is no BOM or a valid UTF8 sequence.

Fixed FindReferences to use TypeRef.IsSameRef() when searching for references to types.

Fixed to properly add a default reference to mscorlib to any "dummy" Project created when loading a CodeUnit or code fragment directly, and fixed type loading logic to default to mscorlib4 types if loading of built-in types fails for any reason.

Fixed a parsing problem with nullable types used with the 'is' or 'as' operators that was not obvious because no errors were shown (but the object tree was not correct).

Fixed to correctly parse 'dynamic = xxx' constructs.

Nova Studio: Minor fix to display the '?' of nullable types in the correct color for primitive types using type names instead of keywords.

Fixed to properly resolve any default values on constructor parameters.

Improvement to implicit reference conversion logic for similar generic types.

Fixed EvaluateType() for the NameOf operator to include the string constant, and also added a GetName() method.

Removed a recent fix which now seems unnecessary and for which no test case seems to exist (type inference involving lambdas that return a 'null' constant).

C# 6.0: Added support for property expressions and method expressions.

C# 6.0: Added support for initializers for auto-properties.

C# 6.0: Added support for the 'nameof' operator.

C# 6.0: Added support for non-numeric error codes for pragma warning directives.

Fixed an issue parsing 'dynamic' as a keyword instead of a variable name if it was a member lookup.

Fixed to handle whitespace between the symbols of the new '?.' operator (very strange C# 6.0 allows this!).

Improved to handle invalid (5-part) version numbers on assembly references.

Improved to treat invalid format (unmanaged) assembly references as warnings rather than errors.

Fixed to properly allow loading of non-specific versions of assemblies from the GAC, and added support for Silverlight SDK assemblies.

Fixed an issue with implicit conversions of open type parameters when they are arrays.

Fixed a problem with output type inference involving lambdas which return a null constant.

Fixed a resolve-phase issue involving the initialization of optional parameters.

NOTE: Possible breaking change: Renamed Reference.Alias to Aliases and Reference.AliasNamespace to AliasNamespaces and made it a List of RootNamespace. Aliases is still a string, but can contain comma-separated values such as "global,MyNamespace".

Improved access checking for constructors to check both the type AND the constructor access, thus fixing possible resolve errors due to multiple matches if the LoadInternalTypes config option was used. Also fixed related issues with partial internal types with the same name existing in multiple projects, and a conflict with IsVisibleTo and internal types.

Added support for conditional project-level define constants.

Added support for co-variance on the return types of lambdas (or anonymous methods) when passing to methods.

Fixed a resolving problem involving nested generic types used as type arguments to other generic types.

Fixed a problem resolving extern aliases when a reference has multiple alias names.

Improvements to parsing of dynamic type for better backward compatibility.

Additional improvement to logic in last release dealing with System.Runtime types from Portable projects.

Fixed an issue with evaluation of arithmetic and bitwise operators when a null constant is involved.

Fixed unresolving to skip arrays of built-in types.

Fixed type inference to determine the common type of a list of params parameters.

Fixed async lambdas (or anonymous methods) with no returns to return type Task.

Fixed a problem rendering compiler directives on base type lists with nested Dot operators.

Fixed an issue resolving method groups during output type inference related to accessibility checking.

Fixed some problems matching parameters during resolving when nested generic types were involved.

Fixed a resolving problem involving enums nested in generic types.

Fixed a resolving problem finding nested generic types used in expressions.

Fixed a resolving problem with multiple matches when LoadInternalTypes was enabled.

Added DocComment.Validate config option to allow turning off of ALL warnings from doc comments.

Changed to treat unresolved refs in using directives as warnings if LoadInternalTypes is false.

C# 6.0: Added support for "?." null-safe dot operator.

Improved the resolving of references to override methods to bind to the most-derived override instead of the base virtual/abstract method declaration, which also means that any default arguments are the proper ones.

Improved Project.FindRef() to do exact matching on type names, and INamespace.Find() and all related methods now have an optional argument to enforce exact matching instead of returning a NamespaceTypeGroup when there are multiple instances of a type due to generics.

Fixed a problem with evaluation of type parameters for generic user-defined implicit conversion operators.

Added support for enum constants as the right operand of a left or right shift operator.

Added handling of System.Runtime types from Portable projects within other projects in the same solution when evaluating and looking up members on those types.

Added a setter to the DocText.Text property.

Added an override of GetIsSameRefHashCode() to AnonymousTypeRef to fix problems inferring type arguments when anonymous types were involved.

Fixed an issue with implicit conversion of method groups involving extension methods.

Fixed a problem with implicit conversions involving type parameters with chained constraints.

Fixed an issue with type inference in a certain scenario involving type parameters.

Fixed a problem with IsSameRef() working properly for TypeParameterRefs when one of them is declared in a base virtual method and the other in an override of that method, thus preventing constraints that appear only on the base method from being considered during resolve processing involving the override method.

Changes to the built-in type caching to ensure that the proper mscorlib version of types are used for each project in a solution, and also added new support for lookup and caching of general TypeRefs at the Project level (such as "System.Type") to avoid similar problems.

Improved the grammar disambiguation logic for casts, and also for nested generic type arguments.

Improved the logic to find the better conversion between two types when constants are involved.

Added support for compiler directives wrapping the default value of a parameter declaration.

Fixed a problem finding members inside other parts of nested generic partial types.

Fixed resolving of the better method when there are no arguments and params and default arguments are involved.

Fixed ForEach to work with nullable types that are enumerable.

Fixed a problem with the defaulting of TypeDecl.IsPublic introduced in 5.31.

Fixed an issue with the evaluation of the type of an await operator when generic type arguments are involved.

Fixed a bug with parsing skipped sections of conditionals containing unclosed quotes introduced a few months ago.

Added a null check in MethodDeclBase.FindBaseMethod(), and added a version of this method to MethodRef.

Fixed the default behavior of Expression.FindTypeArgument() to look at the evaluated type of the expression.

Fixed TypeRef.GetCommonType() to find common interfaces.

Improved support for displaying primitive types as type names instead of keywords added in the last release so that keywords are still used by default in almost all cases except when the type names are used in the source.

Fixed an issue parsing 'is' operators referencing nullable types.

Fixed issues with parsing compiler directives around ParameterDecls, including retaining their newline state. Also fixed an indentation issue with doc comments in skipped sections of compiler directives.

Fixed a possible null argument exception in Project.AreInternalTypesVisibleTo() for web projects.

Prevented a possible infinite loop in TypeRef.FindTypeArgument() involving nested generic types.

Fixed ClassDecl.GetBaseType() to evaluate any type arguments in the current scope.

Improved all TypeDecl modifier properties to return the proper overall modifiers for partial types, and fixed MethodDeclBase.GetAccessRights() to account for extension methods.

Added GetEvent()/GetIndexer() to TypeDecl/ITypeDecl/TypeRef, etc.

Set the ParentProject of AnonymousType instances.

Fixed an issue evaluating type arguments involving nested generic types and constructor initializers that could cause an infinite loop.

Fixed type aliases to handle a rhs name in an imported namespace that matches the alias name without getting in a loop.

Fixed an issue with parsing conditional compiler directives wrapping ParameterDecls.

Fixed MethodDeclBase.FindBaseMethod() to find generic base methods for concrete subclass methods.

Added formatting config options Block.AlignComments and Initializer.Align.

Added support for displaying primitive types as type names instead of keywords if they are declared that way in the original code, unless the AutomaticCodeCleanup option is on. NOTE: This included changing the internal TypeRefBase._pointerCount field to an enum, and moving the FormatFlags.Const flag from CodeObject to the new enum.

Fixed a problem resolving overloaded methods with async lambda arguments.

Fixed a bug introduced in 5.25 where lambda expressions in initializers might not be resolved.

Made a performance improvement for lambda expressions which prevents them from being re-resolved unnecessarily in certain situations.

Added support for platform-specific configuration sections in project files.

Added support for conditional assembly and project references in project files.

Improved and fixed issues with evaluation of conditional macros in project files.

Fixed a problem with null literals when evaluating the common return type of an anonymous method.

Fixed an issue with finding the better match of two statically called extension methods.

Fixed DynamicTypeRef.IsSameRef() to match other DynamicTypeRefs.

Fixed the As operator to support finding type arguments in it's right operand.

Improved implicit identity conversions for type parameters to take constraints into account.

Improved resolving of the Add() method and delegate parameters for collection initializers.

Added support for implicit conversions of arrays to IReadOnlyCollection{T} (.NET 4.5).

Added filtering out of duplicate matches involving imported types.

Fixed an issue with handling of InternalsVisibleTo assembly attributes.

Fixed issues with finding some types of generated files in projects, and also with evaluating certain macros.

Fixed an issue resolving attributes on method parameters.

Fixed TypeDecl.IsGenericType to work properly for nested types of any level, also avoiding a possible stack overflow during type argument evaluation for nested generic types.

Fixed a possible null ref in Resolver.IsSameOrBaseTypeOf() when working with interfaces.

Fixed to treat any '/** ... */' doc comment as a regular block comment if it's not the first thing on the line (for example, inside an expression).

Fixed a possible InvalidCastException in DestructorDecl if used in a doc comment.

Fixed Initializer.EvaluateType() to properly distinguish between multi-dimensional and jagged arrays.

Improved type inference handling of dynamic types.

Fixed member lookups on dynamic types in lambda expressions to resolve properly as DynamicExpressionRefs.

Fixed a problem finding type arguments that belong to nested types.

Fixed a problem evaluating type arguments outside of methods, such as in field declarations.

Fixed a problem involving type arguments and output type inference of method groups.

Fixed type inference and implicit conversion issues involving statically called extension methods.

Fixed new anonymous types with dynamic members to evaluate as a dynamic type.

Improved the logic that evaluates the type of the await operator.

Added logic to filter out duplicate matches caused by redundant using directives.

Merged in a Mono Cecil fix to handle a null resolution scope in an assembly.

Improved to use the project type GUID from the csproj file if the one in the sln file is invalid.

C# 6.0: Added support for 'using' with types to access static members without specifying the type name. Possible Breaking Change: The UsingDirective.Namespace property has been renamed to Expression, however there is a new read-only property named Namespace which returns a NamespaceRef instead of an Expression, so most code should still work unless it was setting the old property.

Fixed TypeDecl.IsAbstract/IsStatic getters to reflect the state across all partial type declarations, and added IsNew/IsSealed.

Fixed IsSameRef() to work properly on AliasRefs with arrays and/or type arguments.

Fixed GetIsSameRefHashCode() to return the same value for an AliasRef and the aliased TypeRef.

Fixed a problem parsing unsafe code using multiple casts and pointers without grouping parenthesis.

Improved the parsing of the return type of delegates to better handle pointer types.

Fixed extension method searching to ignore the 'abstract' modifier on classes since VB does not set it (only 'sealed').

Fixed a problem resolving attributes on type parameters.

Fixed an issue resolving nested generic type arguments to NewObject constructors.

Fixed the 'await' operator to evaluate it's type properly when a struct is used (such as ConfiguredTaskAwaitable{T}).

Fixed resolving of method calls with named arguments where non-optional parameters were not passed.

Fixed a problem resolving inner classes in the base type list.

Improved previous fix regarding determining the best type conversion when literals are involved.

Improved previous fix regarding evaluation of 'var' type initializers involving constants.

C# 6.0 - support for Expression Filters.

Fixed to handle InternalsVisibleTo entries in Project files.

Support for .NET Portable Profiles.

Updated Mono to fix exceptions reading .NET Portable libraries.

Further improvements to macro expression evaluation in Projects.

Added a short-circuit optimization that also prevents a possible stack overflow involving nested classes and type parameter evaluations.

Fixed to filter out any duplicate project references in Project files.

Fixed an issue with accessibility of internal extension methods.

Fixed TypeDecl.GetTypeParameterConstraints() to properly handle partial types where some parts omit the type parameter constraints.

Fixed a problem with lambda re-resolving involving nested generic types.

Fixed an issue determining the better conversion from an expression if it's a Literal.

Fixed type evaluation for Add/Subtract operators for enum types.

Fixed inferred type evaluation for 'var' to handle constant expressions in the initializer expression.

Fixed to only parse the 'await' operator inside 'async' methods.

Improvements to Project handling including: additional properties and unhandled properties, support for imported settings, evaluation of macros including string operations, support for conditional properties including expression evaluation with various operators, handling of the Choose/When/Otherwise construct, and support for wildcards in file specifications.

Fixed to evaluate any macros in the names of assembly references.

Fixed a parsing problem with skipped code sections of conditional compiler directives involving multi-line verbatim strings.

Fixed a possible endless loop with the evaluation of a '??' operator with a lambda on the right side and assigned to a 'var'.

Fixed to handle conversions from char to decimal/double/float when evaluating binary operations on constants.

Fixed an issue with type inference and jagged arrays.

Fixed to not clear resolution members when an UnresolvedRef is cloned.

Implemented proper cloning of the global namespace and assembly resolver objects when a Project is cloned.

Fixed a possible endless loop in type inference involving unresolved type references.

Added DeclaringType/DeclaringMethod properties to Mono.Cecil.GenericParameter.

Fixed a resolving issue with output type inference for match candidates with inferred type arguments.

Fixed to parse compiler directives properly that occur before a comma in an Expression list.

Fixed to stop conditional expression look-ahead if a doc comment is encountered.

Fixed a possible parsing problem involving casts to array types with generic arguments.

Improved parsing of TypeParameters to handle conditional directives.

Fixed to handle 'code' tags in doc comments that contain only a single block comment.

Added GetAdder()/GetRemover() to EventRef.

Fixed Resolver.GetParentArguments() to not modify the Parents of ParameterDecls of explicit interface implementations.

Fixed a problem resolving explicit interface declarations that differ only on ref/out.

Fixed a null ref exception in Project.Clone() for projects without type guids.

Fixed a parsing problem with unsafe pointers using namespace prefixes on the type.

Fixed to handle new VisualStudioVersion and MinimumVisualStudioVersion tags in sln files.

Fixed TypeParameterRef.IsSameRef() to check the total type parameter counts of the declaring type/method in addition to the names.

Added GetGetter()/GetSetter() methods to PropertyRef and the PropertyDeclBase hierarchy that find getters/setters whether in the current class or in a base class.

Fixed post-increment/decrement to properly resolve any user-defined overloaded operators.

Added a CodeDOM.CodeUnit.DefaultEncoding configuration parameter and optional CodeUnit.Load()/ctor parameters to allow changing the default source file encoding from UTF8 (such as to ISO-8859-1).

Added support for Mono Android projects, so that the Mono Android assemblies can be properly found.

Added HasImplicitConversion() to Expression for determining if an expression will undergo an implicit conversion in the context of it's current parent code object (Operator or VariableDecl).

Fixed IVisitor to visit EnumMemberDecls.

Fixed a null reference during type evaluation of initializers that have expressions with mixed array ranks.

Fixed parsing of multi local/field/enum declarations so that the parent object is always non-null during the parsing process, allowing for the evaluation of any compiler directive symbols.

Fixed a null reference if evaluating a compiler directive symbol that has no CodeUnit parent.

Fixed a null reference if there's a single block comment in a 'code' doc comment tag.

Fixed a null reference if a CodeUnit has a null name (useful for code fragments).

Updates to help, and generated with a new version of Sandcastle.

Added EndLineNumber/EndColumnNumber to Block and Initializer, and updated Nova Studio to display in the tool tips.

Added EndRegion to RegionDirective and NextPart to ConditionalDirective, and updated Nova Studio to display the line number of such related objects in the tool tips.

Fixed some cases of double/float/decimal formatting for Literals to use the invariant culture.

Changed Project.Clone() and Solution.Clone() to be deep clones.

Fixed to handle default implicit conversions in addition to user-defined implicit conversions when evaluating the result type of binary operator expressions.

Obsoleted Project.AddFile(), replacing with LoadFile(), and changed public uses to CreateCodeUnit() instead.

Fixed to properly treat non-generic methods as preferable to generic ones when looking for the better overloaded method when there are no method arguments (was working if arguments existed).

Using fixed version of Licensing and Obfuscator tools that resolve problem with running on Ubuntu/Mono.

Added support for resolving the implied Add() method call for collection initializers, and the proper matching of parameter types including lambdas with implied parameter types.

Nova Studio: Added display of the implied Add() method call for collection initializers.

Changed ChildList{T}.Add() to return the added item if it's cloned during the add process, and fixed Block to put such a cloned item in the NamedCodeObjectDictionary instead of the original object.

Added an optional Project parameter to CodeUnit.LoadFragment(), and corrected the doc comments.

Created a Reflection-only version of Nova.CodeDOM.dll.

Fixed a problem resolving method references with more than one unused optional parameter.

Fixed TypeDecl.IsInternal to return false for nested types with no access modifiers set (IsPrivate returns true in this case).

Adjusted the access properties of members to return the appropriate default values if no access modifiers are set, and the access properties of get/set accessors to default to the specified access of their parent property declaration.

Increased the version to 5.0 to reflect full C# 5.0 compatibility.

Fixed a problem with a generic type parameter being evaluated incorrectly in a certain rare scenario.

Fixed a problem matching constructors to a 'new' object in a rare scenario involving nested types, and uncovered only by the above fix.

Fixed so that any overridden config file options are properly logged (if Detailed logging is on) AFTER any logging callback is installed.

Added Pre/PostBuildEvent parsing and properties for Projects.

Added support for Windows Phone projects, automatically referencing all framework assemblies.

Nova Studio: Added individual Diff to solution/project file context menus, and also to the File menu and toolbar (for the currently open file).

Fixed an issue evaluating type parameters when the result is a type parameter array.

Improved evaluation of constant expressions to work with alternate core libraries.

Fixed possible exception with multi-threading and default constructor generation.

Fixed an issue inferring the types of lambda args when the lambda is used to assign a property in an object initializer for a generic type instance.

Nova Studio: Added support for specifying a file to load on the command line.

Fixed a bug allowing implicit conversion of 'object' to a type argument. Fixed several problems exposed by this fix, including implicit conversion of type argument arrays to various interfaces, proper evaluation of type arguments for type constraints and parameters of delegate fields, getting constraints for explicit interface implementations from the interface, and evaluation of type arguments in certain situations inside doc comments.

Fixed to stop searching when finding a type argument in a parent Cast operator.

Fixed a problem parsing the last initialization of a flags enum.

Fixed an issue parsing a LocalDecl instead of an expression in a using statement.

Turned on Server-mode garbage collection by default, giving better performance on 2 or more cores. Parsing is now about twice as fast.

WARNING: Possibly slower on a single core - can be disabled in the config file.

New WIX installation - now updates existing installations.

Added specially-built binaries that will run on Mono.

Improved parsing to handle some rare issues, and various other improvements.

Nova Studio: Minor improvements.

Corrected a problem with the 30-day evaluation license.

NOTE: The AutomaticCodeCleanup and AutomaticFormattingCleanup options now default to false.

Fixed dynamic type references to be treated as resolved for purposes of lambda expression binding.

Fixed an issue in FindBetterMethod() with the tie-breaking rules involving more specific types.

Fixed TypeRef.GetProperty() to look in base interfaces for interface types.

Fixed resolving to ignore interface constraints on a generic type when a complete match already exists.

Fixed resolving of Else/ElseIf/Catch/Finally to ignore the body of the parent If/ElseIf/Try.

Fixed a parsing issue with a regular comment terminating the parsing of a DocCode.

Nova Studio: Fixed an issue with virtualized rendering of nested blocks in a certain situation.

Improved exception handling in licensing logic.

Fixed to match InternalsVisibleTo on the assembly name instead of the project name.

Nova Studio: Added some null ref checks when rendering implicit operators in tooltips.

Fixed possible null ref exception in TypeRef.GetMethod().

Fixed to handle the executing assembly having a null location, which can occur if the DLL is embedded as a resource in the calling assembly. In this case, the path of the entry assembly is used instead.

BREAKING CHANGES: Converted to new licensing/obfuscation tool to solve a problem with running in 64-bit mode. A NEW LICENSE KEY IS REQUIRED FOR THIS VERSION - new codes will be emailed to all existing customers, but the product will run with the evaluation license for 30 days until you receive your new license code.

Performance improvements of up to 2X faster related to the obfuscation tool change and reduced obfuscation.

Fixed to look in parent directories of the project for referenced assemblies if the hintpath doesn't work.

Fixed to check for indexers on the 'object' type if an alternate core library is used.

Nova Studio: Fixed problem with descriptions of Mono Cecil metadata for enum types showing 'struct' instead of 'enum'.

Added support for user-defined operators on built-in types when an alternate core library is used.

Added FindIndexOf(CodeObject) and Replace(CodeObject, CodeObject) to Block and BlockStatement, and improved to allow adding/inserting a Block into a Block or BlockStatement (expanding it to its children in the process).

Nova Studio: Added display of implicit conversion operators in tool-tips when applied to expressions, and support for some context menu items inside tooltips such as Go To Declaration.

BREAKING CHANGES: Reverted to the strong name in use prior to v4.8, made possible because ILMerge is no longer being used, and necessary to workaround a problem with the licensing tool and strong names. You may need to remove and re-add references to Nova.CodeDOM.dll due to the strong name change. Sorry for any inconvenience, but the benefit is that Nova.CodeDOM.dll should once again work with strong-named calling assemblies.

Fixed to look up indexer refs in the 'object' type to support alternate core libs with indexers on 'object'.

Added support for setting Mono.Cecil.TypeSystem.AltCorLibName in the config file.

Fixed to ignore any authorization or other exceptions trying to write the user options (.nuo) file, and to re-load properly with the new settings regardless.

Fixed to expand macros in hint paths when loading referenced assemblies (either $(NAME) or %NAME%).

BREAKING CHANGES: Made EmptyStatement obsolete with special parsing and rendering changes - remove any uses of this class. Also, BlockStatement.HasEmptyDefault was renamed to RequiresEmptyStatement.

Changed to a version of Mono Cecil that is multi-thread safe for reads, better integrated with Nova, and has support for an alternative core library (other than "mscorlib").

Added static constructors to all types with config options to ensure the config file is loaded before their settings are manually changed.

Fixed a static initialization order problem in TypeRef.

Added some protections for multi-threading during dynamic loading of assemblies caused by type resolution.

Nova Studio: Minor improvements to tooltip info for comments.

Fixed GetAllChildren{T}() to exclude the parent object.

Fixed Clone() issue causing Parent references of child collections in the source object to become null.

Fixed Literal.GetValue() to parse negative values correctly.

Fixed issue with comments on top-level expressions in a Block causing parse errors.

Fixed to take user-defined implicit string conversion operators into account when evaluating possible string concatenation.

Fixed logic that clears comment newlines when the newlines of the parent are removed to only affect prefix comments.

Nova Studio: Added flags and parent info to tooltip for Comments.

Fixed a bug in Block.Clone() that would cause child ConstructorDecls to throw an exception.

Fixed to ignore AutomaticFormattingCleanup and AutomaticCodeCleanup options for generated files.

Nova Studio: Fixed handling of sub-folders named 'References'.

Fixed a bug in MethodRef.GetFullName() causing it to return null for external methods.

Nova Studio: Fixed to properly highlight projects with errors if they're in solution folders.

Fixed a nasty interaction with .NET 4.5 preventing Nova.CodeDOM.DLL from running on .NET 4.0 even though it's targeted to 4.0.

Nova Studio: Support for solution folders, improvements to tab control.

Fixed build sequencing problem causing assembly version mismatch preventing Nova Studio from running.

Class documentation is now online instead of in the local Help file, making the installation package 25 MB smaller.

Type loading and parsing are now multithreaded (can be disabled with CodeDOM.Project.DisableMultithreading in the .config file).

DoNotParseBodies and DoNotResolveBodies flags added to LoadOptions for skipping the parsing and/or resolving of all method bodies for scenarios in which they aren't needed.

Fixed missing strong name on Nova.CodeDOM.dll due to use of ILMerge for Mono Cecil support.

Bug fixes for things such as: Some new issues when using Reflection instead of Mono Cecil, various other minor issues.

Nova Studio: Performance improvement while loading solutions.

Major changes to resolving to be single-pass, preventing poor performance when there are many errors. Various related improvements. Also, fixed resolving to enforce accessibility up front rather than filtering if there are multiple matches.

Breaking changes: NamespaceDecl.GetAllTypeDecls() has been changed to GetTypeDecls(true).

Some breaking changes were made to the 'Find()' methods in the Block and BlockStatement classes: Renamed T Find{T}() to T FindFirst{T}() to make way for IEnumerable{T} Find{T}(). Renamed INamedCodeObject Find(string name) to INamedCodeObject FindChildren(string name). Renamed void Find{T}(string name, NamedCodeObjectGroup results) to void FindChildren{T}(string name, NamedCodeObjectGroup results). Added IEnumerable{T} Find{T}(string name) and T FindFirst{T}(string name). The 'FindChildren' methods are lower-level, and the methods using IEnumerable should be preferred.

Bug fixes for things such as: Overloaded method resolution with overrides, proper resolving order for parent namespaces specified in a NamespaceDecl, multi-variable types not being cloned properly, possible stack overflow in Nova Studio.

Nova Studio: Added types/members dropdowns, improvements to tooltip behavior.

Added nested tooltips and 'Go To Declaration' on the context menu for the Nova Studio UI.

Various minor bug fixes, related to things such as: Overloaded method selection, type inference, anonymous method parent delegates, find better conversion, variance conversion, parallel queries, nullable type arithmetic, anonymous type property re-generation, parsing of C++ projects, .NET 3.5 Client Profile projects, duplicate GAC entries, rendering of type arguments for GenericTypeInstances, selection of objects in the UI.

Virtualized Nova Studio UI rendering for better performance.

Changed to attempt parsing of any unsupported project types, so that output assemblies can be found and loaded if possible.

SymbolicRefs no longer have Equals()/GetHashCode() giving the same results if IsSameRef() is true - they are now always unique. Use IsSameRef(), GetIsSameRefHashCode(), or IsSameRefComparer if you wish SymbolicRefs that refer to the same object to be treated as identical.

Fixed a parsing problem with lambdas with explicitly typed generic parameters.

Fixed IsInternal/IsPrivate to properly default for TypeDecls with no modifiers.

Fixed to properly filter out nested types when loading with Mono Cecil.

Renamed the LoadInternalTypes option, and fixed a type resolution issue with it.

Improvements to display options, and added to config file.

ATTENTION: Changed to load assemblies using Mono Cecil by default (you may set ApplicationContext.UseMonoCecilLoads to false with code or in the .config file to revert to using Reflection instead).

Improvements to handling and display of user-defined operators and pointer types.

Changed Namespace to use new NamespaceTypeDictionary/NamespaceTypeGroup instead of NamedCodeObjectDictionary/NamedCodeObjectGroup.

Fixed possible exception in parsing special types of block comments.

Improved Line/Column Number support, including auto-updating when CodeUnits are saved or displayed as text.

Fixed handling of external members with dynamic types, including proper display in Nova Studio.

Various fixes related to the UI refactoring, including fixing direct loading of .csproj files.

Fixed the evaluation of type argument types to always make sure the declaring types match.

Fixed a problem with proper type argument evaluation while inferring type arguments.

Fixed type parameter references to always be implicitly convertible to 'object'.

Fixed LINQ expressions to evaluate to an IOrderedEnumerable<T> type if they have an 'order by' clause.

Enabled lookup of extension methods on anonymous types (valid for arrays or 'object' extensions).

Fixed so that anonymous object initializers that specify a sequence of properties of the same names and compile-time types in the same order will produce instances of the same anonymous type.

Added support for Portable Library profiles, and check for loading of proper framework assembly versions.

Fixed a nasty resolving bug introduced in 4.2.

Fixed a null reference exception in a special case evaluating the type of a lambda parameter.

Fixed a parsing problem confusing a nullable type parameter with a Conditional.

Added new Log.LogLevel config setting with values: None, Minimal, Normal, Detailed

Changed LoadOptions so that LogMetrics and LogMessages must be explicitly specified.

The Nova CodeDOM assembly is now signed, so it can be referenced from signed assemblies.

Removed dependencies on many assemblies from Nova CodeDOM, including WPF assemblies. Moved all UI code into new Nova.UI assembly, and refactored Nova CodeDOM to use it.

Added improved support for LINQ queries on CodeObjects, and examples.

Added support for the SLOC metric (and those calculated from it) for code fragments.

Changed CodeDOM major version to 4 to match the supported version of C# to avoid any confusion.

Added LineNumber and Column properties to all CodeObjects (and Messages).

Various improvements to parsing of invalid code and parser error messages.

Fixed problem with not taking user-defined implicit conversions into account when evaluating built-in binary operators.

Implemented IncludeMemberReferences, IncludeDerivedTypes, IncludeOverrides, and IncludeOverloads options for FindReferences.

The Solution.Projects and Project.CodeUnits collections are now sorted alphabetically so that the results of Find operations are sorted.

Fixed a problem resolving invocations of properties or fields with a generic type that evaluates to a delegate type.

Added support for ReferencePath in a project or '.user' file.

Fixed a bug involving Aliases that could cause an exception.

Added support for Find References, Find By Type, and Find By Text.

Fixed an infinite recursion bug with resolving nested, partial, generic types.

Fixed a bug with relative paths. Fixed a threading problem with ObservableCollection.

Fixed issues with visitor evaluation order, and a few missed items.

Changed EXEs to x86 (32-bit). Added Configuration/Platform control.

Added additional content to the Help file and removed obsolete text files.

Renamed the ReferenceBase class to Reference.

Exposed the FileItems property in Project.

Added a Help file for all Nova CodeDOM types and members.

Added InstallShield Install/Uninstall support (.msi).

Added support for the Visitor design pattern to traverse the object tree.

First public release. Full C# 4.0 support, plus 'async'.