private TypeCheckingArgumentsDefinition(IList<Argument> arguments, ICollection<string> keywords, string rest, string krest, int min, int max, bool restUneval, IList<ITypeChecker> mustMimic, ITypeChecker receiverMustMimic) : base(arguments, keywords, rest, krest, min, max, restUneval) { this.arguments = arguments; this.mustMimic = mustMimic; this.receiverMustMimic = receiverMustMimic; }
public static T GetHelper <T>(AST root, ITypeChecker parent) where T : ITypeHelper, new() { var helper = new T(); helper.Initialize(root, parent.Dispatch); return(helper); }
/// <summary> /// Returns whether or not the symbol is a type, or if it references a module that has exported types. /// </summary> /// <remarks> /// Note: This was ported directly from the TypeScript implementation. The name of the function /// isn't exactly representative of what it is doing. /// </remarks> private static bool SymbolCanBeReferencedAtTypeLocation(ISymbol symbol, ITypeChecker typeChecker) { symbol = symbol.ExportSymbol ?? symbol; symbol = SkipAlias(symbol, typeChecker); if ((symbol.Flags & SymbolFlags.Type) != SymbolFlags.None) { return(true); } if ((symbol.Flags & SymbolFlags.Module) != SymbolFlags.None) { var exportedSymbols = typeChecker.GetExportsOfModule(symbol); foreach (var exportedSymbol in exportedSymbols) { if (SymbolCanBeReferencedAtTypeLocation(exportedSymbol.Value, typeChecker)) { return(true); } } } return(false); }
public AnalyzedSourceFile(ITypeChecker checker, ISourceFile sourceFile, ISourceFile[] files, PathTable pathTable) { m_pathTable = pathTable; DownStreamDependencies = MaterializeBitSet(checker.GetFileDependentsOf(sourceFile), files); UpStreamDependencies = MaterializeBitSet(checker.GetFileDependenciesOf(sourceFile), files); UpStreamModuleDependencies = checker.GetModuleDependenciesOf(sourceFile); }
internal static CommonOperatorHelper GetCommonHelper(ITypeChecker parent) { var res = new CommonOperatorHelper(); res.Initialize(GetAst(), parent.Dispatch); return(res); }
public Program(string[] args) { config = GetConfig(); ParseArgs(args); _lexParse = new LexParser(new ASTBuilder(new ExpressionHelper())); _referenceHandler = new ReferenceHandler(new ReferenceHelper(), !_shouldThrowExceptions); _typeChecker = new TypeChecker(new DeclarationHelper(), new NumberHelper(), new CommonOperatorHelper(), new TypeBooleanHelper(), new TypeSetHelper()); _interpreter = new Interpreter(new GenericHelper(), new FunctionHelper(), new IntegerHelper(), new RealHelper(), new InterpBooleanHelper(), new InterpreterSetHelper(), new ElementHelper(), new StringHelper(), new GraphHelper(), !_shouldThrowExceptions); _outputGenerator = _output == OutputLanguage.DOT ? (IOutputGenerator) new DotGenerator() : (IOutputGenerator) new GmlGenerator(); _fileGenerator = new FileGenerator(new FileHelper()); _exceptionPrinter = new ExceptionPrinter(); _fileReader = new FileReader(new FileHelper()); }
/// <inheritdoc/> public void Initialize(ITypeChecker checker, TypeFlags flags, ISymbol symbol) { // Checker argument is used only by services.ts, but we're leaving it here for compatibility reasons. Flags = flags; // HINT: to simplify the code and design, this initialize method sets Id as well. Initialize(checker.GetNextTypeId(), flags, symbol); }
private static void SetTypeCheckerDefaultValues(ITypeChecker typeChecker) { typeChecker.Dispatch(Arg.Any <RealLiteralExpression>(), Arg.Any <List <TypeNode> >()).Returns(new TypeNode(TypeEnum.Real, 1, 1)); typeChecker.Dispatch(Arg.Any <IntegerLiteralExpression>(), Arg.Any <List <TypeNode> >()).Returns(new TypeNode(TypeEnum.Integer, 1, 1)); typeChecker.Dispatch(Arg.Any <BooleanLiteralExpression>(), Arg.Any <List <TypeNode> >()).Returns(new TypeNode(TypeEnum.Boolean, 1, 1)); typeChecker.Dispatch(Arg.Any <StringLiteralExpression>(), Arg.Any <List <TypeNode> >()).Returns(new TypeNode(TypeEnum.String, 1, 1)); typeChecker.Dispatch(Arg.Any <SetExpression>(), Arg.Any <List <TypeNode> >()).Returns(new TypeNode(TypeEnum.Set, 1, 1)); typeChecker.Dispatch(Arg.Any <GraphExpression>(), Arg.Any <List <TypeNode> >()).Returns(new TypeNode(TypeEnum.Graph, 1, 1)); }
public RenderContext(UIElementBase root, RenderInfo ri) { Writer = ri.Writer; _root = root; _dataModel = ri.DataModel; _localizer = ri.Localizer; _currentLocale = ri.CurrentLocale; _typeChecker = ri.TypeChecker; IsDebugConfiguration = ri.IsDebugConfiguration; }
/// <summary> /// Computes semantic workspace from parsed workspace. /// </summary> /// <remarks> /// If this is not the first time specs in this workspace are type checked, the semantic model that resulted in a previous check is expected to be passed /// </remarks> public async Task <Workspace> ComputeSemanticWorkspaceAsync(PathTable pathTable, Workspace workspace, [CanBeNull] ISemanticModel originalSemanticModel = null, bool incrementalMode = false) { Contract.Requires(workspace != null); ITypeChecker checker = await MeasureCheckingDurationAsync( workspace, w => TypeCheckWorkspace(pathTable, workspace, m_workspaceConfiguration.MaxDegreeOfParallelismForTypeChecking, originalSemanticModel, incrementalMode)); return(workspace.WithSemanticModel(new SemanticModel(checker), workspace.FilterWasApplied)); }
/// <nodoc/> public static T CreateType <T>(ITypeChecker checker, TypeFlags flags, ISymbol symbol) where T : IType, new() { // new() expression will use Activator.CreateInstance under the hood, // and this has significant performance impact. // Custom expression-tree-based solution preserves the same behavior but lacks performance issues. var type = FastActivator <T> .Create(); type.Initialize(checker, flags, symbol); return(type); }
public ThreeFiles(PathTable pathTable, ITypeChecker checker, [NotNull] ISourceFile spec1, [NotNull] ISourceFile spec2, [CanBeNull] ISourceFile spec3, ISourceFile[] files) : this() { Spec1 = new AnalyzedSourceFile(checker, spec1, files, pathTable); Spec2 = new AnalyzedSourceFile(checker, spec2, files, pathTable); if (spec3 != null) { Spec3 = new AnalyzedSourceFile(checker, spec3, files, pathTable); } }
public static T GetHelper <T>(AST root) where T : ITypeHelper, new() { ITypeChecker parent = Substitute.For <ITypeChecker>(); SetTypeCheckerDefaultValues(parent); var helper = new T(); helper.Initialize(root, parent.Dispatch); return(helper); }
/// <summary> /// Returns an enumeration of symbols from the specified types. /// </summary> public static IEnumerable <ISymbol> GetSymbolsFromTypes(ITypeChecker typeChecker, IEnumerable <IType> types) { HashSet <ISymbol> symbols = new HashSet <ISymbol>(); foreach (var type in types) { symbols.AddRange(typeChecker.GetPropertiesOfType(type)); } return(symbols); }
private static FileContent GetPublicSurface(ISourceFile originalFile, ITypeChecker checker) { using (var writer = new ScriptWriter()) { var printer = new PublicSurfacePrinter(writer, new SemanticModel(checker)); FileContent publicContent; var result = printer.TryPrintPublicSurface(originalFile, out publicContent); XAssert.IsTrue(result); return(publicContent); } }
/// <nodoc/> public CompletionState(INode startingNode, TextDocumentPositionParams positionParameters, ITypeChecker typeChecker, Workspace workspace, PathTable pathTable) { Contract.Requires(startingNode != null); Contract.Requires(positionParameters != null); Contract.Requires(typeChecker != null); Contract.Requires(workspace != null); Contract.Requires(pathTable != null); StartingNode = startingNode; PositionParameters = positionParameters; TypeChecker = typeChecker; Workspace = workspace; PathTable = pathTable; }
public static List <ISourceFile> Analyze( out ITypeChecker checker, ParsingOptions parsingOptions = null, bool implicitReferenceModule = false, params string[] codes) { var testFiles = GenerateTestFileNames("dsc", codes); return(Analyze( out checker, useCachedVersion: false, parsingOptions: parsingOptions, implicitReferenceModule: implicitReferenceModule, tsInputFiles: testFiles)); }
/// <nodoc /> public static string GetDeclaredName(ITypeChecker typeChecker, ISymbol symbol, INode location) { // If this is an export or import specifier it could have been renamed using the 'as' syntax. // If so we want to search for whatever is under the cursor. if (IsImportOrExportSpecifierName(location)) { return(location.GetText()); } // Try to get the local symbol if we're dealing with an 'export default' // since that symbol has the "true" name. var localExportDefaultSymbol = GetLocalSymbolForExportDefault(symbol); return(typeChecker.SymbolToString(localExportDefaultSymbol ?? symbol)); }
private static IEnumerable <IType> GetAllTypesIfUnion(IType type, ITypeChecker typeChecker, HashSet <IType> types) { if ((type.Flags & TypeFlags.Union) != TypeFlags.None) { foreach (var unionType in type.Cast <IUnionType>().Types) { types.AddRange(GetAllTypesIfUnion(unionType, typeChecker, types)); } } else { types.Add(type); } return(types); }
/// <summary> /// Analyze all source files. /// </summary> public static List <ISourceFile> Analyze( out ITypeChecker checker, bool useCachedVersion = false, ParsingOptions parsingOptions = null, bool implicitReferenceModule = false, params TestFile[] tsInputFiles) { LazyInitializer.EnsureInitialized(ref s_libFile, () => File.ReadAllText("Libs/lib.core.d.ts")); // Need to parse lib.d.ts file each time, because checker mutates ISourcefile // var parsedLibFile = s_parsedSourceFile;//threadLocalSource.Value; var parsedLibFile = LazyInitializer.EnsureInitialized(ref s_parsedLibFile, ParseLib); if (!useCachedVersion) { // See comment in StringBasedCheckerTests.CheckAnalysisOrderIssue for more details! parsedLibFile = ParsingHelper.ParsePotentiallyBrokenSourceFile(s_libFile, "lib.core.d.ts", parsingOptions); } var sourceFiles = tsInputFiles.Select( tsInputFile => ParsingHelper.ParsePotentiallyBrokenSourceFile(tsInputFile.Content, tsInputFile.UnitName, parsingOptions)).ToList(); var sourceFilesWithLib = new List <ISourceFile>(sourceFiles) { parsedLibFile }; // Need to parse lib.d.ts file every time, because checker mutates it and this could lead to failure // when multiple checking processes are running in parallel. // var parsedLibFile = ParseOrDeserialize(s_libFile);// ParsingHelper.ParseSourceFile(s_libFile, "lib.d.ts"); ModuleName?fakeModule = new ModuleName("fakeModule", implicitReferenceModule); var host = new TypeCheckerHostFake(fakeModule, sourceFilesWithLib.ToArray()); checker = Checker.CreateTypeChecker(host, true, degreeOfParallelism: 1); return(sourceFiles); }
public static IType GetTypeOfFirstVariableDeclarationOrDefault(this IVariableStatement variableStatement, ITypeChecker typeChecker) { var firstDeclaration = GetFirstDeclarationOrDefault(variableStatement); if (firstDeclaration == null) { return(null); } return(typeChecker.GetTypeAtLocation(firstDeclaration)); }
/// <nodoc/> public GotoDefinitionHelper(ITypeChecker typeChecker) { TypeChecker = typeChecker; }
public Or(ITypeChecker first, ITypeChecker second) { this.first = first; this.second = second; }
/// <nodoc/> public SemanticModel(ITypeChecker typeChecker) { Contract.Requires(typeChecker != null); TypeChecker = typeChecker; }
public Builder ReceiverMustMimic(IokeObject mimic) { this.receiverMustMimic = mimic; return(this); }
public Builder ReceiverMustMimic(IokeObject mimic) { this.receiverMustMimic = mimic; return this; }
/// <summary> /// Given a <paramref name="type"/>, returns the symbols that can be accessed relative to <paramref name="node"/> /// </summary> /// <param name="type">The type whose symbols will be tested for valid property access.</param> /// <param name="node">The node in which the type's symbols will be accessed.</param> /// <param name="typeChecker">Reference to the type checker.</param> /// <remarks> /// Ported from TypeScript version. /// </remarks> private static IEnumerable <ISymbol> AddTypeProperties(IType type, INode node, ITypeChecker typeChecker) { var typeSymbols = typeChecker.GetPropertiesOfType(type); if (typeSymbols != null) { return(typeSymbols.Where(typeSymbol => typeSymbol.Name != null && typeChecker.IsValidPropertyAccess(node.Parent /*HINT: IPropertyAccessExpression*/, typeSymbol.Name))); } return(Enumerable.Empty <ISymbol>()); }
/// <nodoc/> public static TObjectType CreateObjectType <TObjectType>(ITypeChecker checker, TypeFlags kind, ISymbol symbol) where TObjectType : IObjectType, new() { return(CreateType <TObjectType>(checker, kind, symbol)); }
/// <summary> /// Creates an array of symbols for a node whose parent is either a qualified name or a property access expression. /// </summary> /// <remarks> /// This was ported from the TypeScript version of the language server. /// </remarks> public static IEnumerable <ISymbol> GetTypeScriptMemberSymbols(INode node, ITypeChecker typeChecker) { var symbols = new HashSet <ISymbol>(); // If we are part of a type (say creating an interface and and assigning a type to a property) // interface Test { // myField: ImportedModuleQualifiedName.<Type> // }; // when we want to filter the symbols ot the types bool isTypeLocation = node.Parent != null && IsPartOfTypeNode(node.Parent); // This case handles when you are accessing a property out of // an import statement. // const foo = importFrom("").<Type or Value>. // NOTE: We don't really hit this case in our completion implementation // as it is already handled as part of the property access expression completion code. bool isRhsOfImportDeclaration = IsInRightSideOfImport(node); if (IsEntityNode(node)) { var symbol = typeChecker.GetSymbolAtLocation(node); if (symbol != null) { symbol = SkipAlias(symbol, typeChecker); if ((symbol.Flags & (SymbolFlags.Enum | SymbolFlags.Module)) != SymbolFlags.None) { var exportedSymbols = typeChecker.GetExportsOfModule(symbol); foreach (var exportedSymbol in exportedSymbols) { if (isRhsOfImportDeclaration) { if (typeChecker.IsValidPropertyAccess(node.Parent, exportedSymbol.Value.Name) || SymbolCanBeReferencedAtTypeLocation(exportedSymbol.Value, typeChecker)) { symbols.Add(exportedSymbol.Value); } } else if (isTypeLocation) { if (SymbolCanBeReferencedAtTypeLocation(exportedSymbol.Value, typeChecker)) { symbols.Add(exportedSymbol.Value); } } else { if (typeChecker.IsValidPropertyAccess(node.Parent, exportedSymbol.Value.Name)) { symbols.Add(exportedSymbol.Value); } } } // If the module is merged with a value, we must get the type of the class and add its propertes (for inherited static methods). if (!isTypeLocation && symbol.Declarations != null && symbol.Declarations.Any(d => d.Kind != SyntaxKind.SourceFile && d.Kind != SyntaxKind.ModuleDeclaration && d.Kind != SyntaxKind.EnumDeclaration)) { symbols.AddRange(AddTypeProperties(typeChecker.GetTypeOfSymbolAtLocation(symbol, node), node, typeChecker)); } } } } // If we are not in a type location, and not handling module exports, then add the symbols for the // type of the "left side" (i.e. the "QualifiedName" in "QualifiedName."Access") that can be accessed // through QualifiedName (i.e. if the user types QualifiedName.<Completion happens here> what symbols // have valid property access from there). if (!isTypeLocation) { symbols.AddRange(AddTypeProperties(typeChecker.GetTypeAtLocation(node), node, typeChecker)); } return(symbols); }
/// <summary> /// Creates a unique set of strings representing the string literal types present in the given type (and all unions if present) /// </summary> private static IEnumerable <string> AddStringLiteralSymbolsFromType(IType type, ITypeChecker typeChecker) { var completionStrings = GetAllTypesIfUnion(type, typeChecker). Where(t => ((t.Flags & TypeFlags.StringLiteral) != TypeFlags.None)). Select(t => t.Cast <IStringLiteralType>().Text).Distinct(); return(completionStrings); }
/// <summary> /// Attempts to add a file to a source file list. The conditions that must be met are specified in the /// array of <paramref name="configurations"/> /// </summary> public static bool TryAddSourceFileToSourceFile(ITypeChecker checker, ISourceFile sourceFile, string sourceFileName, Workspace workspace, PathTable pathTable, AddSourceFileConfiguration[] configurations) { INode sourcesNode = null; try { // Use single or default to ensure that we only match a single sources property. // If we find more than one, we don't know which source file list to augment. // SingleOrDefault throws an InvalidOperationException if it finds more than one element // and returns default<T> if there are 0. sourcesNode = NodeWalker.TraverseBreadthFirstAndSelf(sourceFile).SingleOrDefault(node => { // We expect that the property for the source file list to be in an object literal // and hence be a property assignment inside that object literal. // The statement will look something like: // const result = TargetType.build( { sources: [f`foo.cpp`] } ); if (node.Kind == SyntaxKind.PropertyAssignment && node.Cast <IPropertyAssignment>().Name.Kind == SyntaxKind.Identifier && node.Parent?.Kind == SyntaxKind.ObjectLiteralExpression) { var propertyName = node.Cast <IPropertyAssignment>().Name.Text; // Now check the configurations to see if the any match as there // can be different names (such as "references", "sources", etc.) as // well as different functions, etc. AddSourceFileConfiguration singleConfiguration = null; try { // We use single or default to ensure that only one matching configuration is found. // SingleOrDefault throws an InvalidOperationException if it finds more than one element // and returns default<T> if there are 0. singleConfiguration = configurations.SingleOrDefault(configuration => { // Check to see if this is the correct property name. if (propertyName != configuration.PropertyName) { return(false); } // Now we will try to find the matching call expression (function name) // The reason we are going to walk parent nodes is that we allow // a "merge" or "override" to be nested inside the function call // as long as the argument type and the expected module the type exists // in match the configuration parameter. var nodeParent = node.Parent.Parent; while (nodeParent != null) { if (nodeParent.Kind != SyntaxKind.CallExpression) { return(false); } var callExpression = nodeParent.Cast <ICallExpression>(); string calledFunction = string.Empty; // Depending on the module the function is being called from it may be a straight // call (such as "build()") or it could be an accessor if it was imported // from another module (such as "StaticLibrary.build()"). if (callExpression.Expression?.Kind == SyntaxKind.PropertyAccessExpression) { var propertyAccessExpression = callExpression.Expression.Cast <IPropertyAccessExpression>(); calledFunction = propertyAccessExpression.Name?.Text; } else if (callExpression.Expression?.Kind == SyntaxKind.Identifier) { calledFunction = callExpression.Expression.Cast <Identifier>().Text; } else { return(false); } // If the called function matches, and has the minimum number of parameters to contain our argument type // then verify it matches the type name given in the configuration. if (calledFunction == configuration.FunctionName && callExpression.Arguments?.Length > configuration.ArgumentPosition) { var type = checker.GetContextualType(callExpression.Arguments[configuration.ArgumentPosition]); if (type != null && IsTypeCorrectForAddSourceFileConfiguration(type, workspace, pathTable, configuration)) { return(true); } } else if (DScriptUtilities.IsMergeOrOverrideCallExpression(callExpression)) { // In the case of a merge or override function, we make sure it is the proper type and keep moving // up the parent chain to find the function call. var type = checker.GetTypeAtLocation(callExpression.TypeArguments[0]); if (type != null && IsTypeCorrectForAddSourceFileConfiguration(type, workspace, pathTable, configuration)) { nodeParent = nodeParent.Parent; continue; } } return(false); } return(false); }); } catch (InvalidOperationException) { return(false); } return(singleConfiguration != null); } return(false); }); } catch (InvalidOperationException) { } if (sourcesNode != null) { var propertyAssignment = sourcesNode.Cast <IPropertyAssignment>(); // Will support array literals for now. var initializer = propertyAssignment.Initializer.As <IArrayLiteralExpression>(); if (initializer == null) { // TODO: potentially we could have a glob call here, and what we can do this: // [...(oldExpression), newFile] return(false); } var alreadyPresent = initializer.Elements.Any(element => { return(element.Kind == SyntaxKind.TaggedTemplateExpression && element.Cast <ITaggedTemplateExpression>().Template?.Text.Equals(sourceFileName, StringComparison.OrdinalIgnoreCase) == true); }); if (!alreadyPresent) { initializer.Elements.Add(new TaggedTemplateExpression("f", sourceFileName)); return(true); } } return(false); }
protected PropertyValidationAttribute(ITypeChecker validationType) { if (validationType == null) throw new ArgumentNullException("validationType"); this.ValidationType = validationType; }
private TypeCheckingArgumentsDefinition(IList <Argument> arguments, ICollection <string> keywords, string rest, string krest, int min, int max, bool restUneval, IList <ITypeChecker> mustMimic, ITypeChecker receiverMustMimic) : base(arguments, keywords, rest, krest, min, max, restUneval) { this.arguments = arguments; this.mustMimic = mustMimic; this.receiverMustMimic = receiverMustMimic; }