protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { var prefixList = this.Objectexp.Symbol.GetExpressions(packagesContext, expContext); if (prefixList.Length != 1) { throw new SyntaxException(string.Format("Cannot resolve symbol {0}", this.MemberValue), this.Member.Line, this.Member.Column); } var prefix = prefixList[0]; switch (prefix.Classify) { case ExpressionType.Value: if (prefix.Type.Name == Type.Function.Name && prefix.Type.PackageName == Type.Function.PackageName) { throw new SyntaxException(string.Format("Cannot resolve global symbol {0}", this.MemberValue), this.Member.Line, this.Member.Column); } if (prefix.Type == Type.Table || prefix.Type == Type.Any) { return(new[] { new Expression() { Classify = ExpressionType.Value, Type = Type.Any } }); } var c = packagesContext.GetClass(prefix.Type.Name); if (c == null) { throw new SyntaxException(string.Format("Cannot resolve symbol {0}", this.MemberValue), this.Member.Line, this.Member.Column); } return(this.GetExpTypeAsVariable(packagesContext, expContext, c)); case ExpressionType.Class: if (prefix.Type == Type.Any) { this.accessType = ""; return(this.GetExpressionsWithValue(Type.Any)); } if (prefix.Type == Type.Table) { return(this.GetExpressionsWithValue(Type.Any)); } c = packagesContext.GetClass(prefix.Type.Name); if (c == null) { throw new SyntaxException(string.Format("Cannot resolve symbol {0}", this.MemberValue), this.Member.Line, this.Member.Column); } return(this.GetExpTypeAsClass(packagesContext, expContext, c)); case ExpressionType.This: return(this.GetExpTypeAsVariable(packagesContext, expContext, expContext.ClassContext)); case ExpressionType.Super: if (expContext.ParentContext != null && expContext.ParentContext is Class) { return(this.GetExpTypeAsVariable(packagesContext, expContext, expContext.ParentContext)); } break; } throw new SyntaxException(string.Format("Cannot resolve symbol {0}", this.MemberValue), this.Member.Line, this.Member.Column); }
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { return(this.GetExpressions(new Expression() { Classify = ExpressionType.Super })); }
private static PackagesLock ExtractLock(PackagesContext context) { return(new PackagesLock(context.Packages.ToImmutableDictionary(x => x, x => (IImmutableList <PackageIdentity>)context.PackageDependencies[x].Dependencies .Select(y => context.Packages.FirstOrDefault(z => z.Id == y.Id)).Where(y => y != null) .ToImmutableList()))); }
private IEnumerable <ResolvedAction> GetRequiredActions(PackagesContext context) { var packagesToUninstall = new HashSet <PackageIdentity>(_project.InstalledPackages.Select(x => x.Key), PackageIdentity.Comparer); var packagesToInstall = new HashSet <PackageIdentity>(PackageIdentity.Comparer); foreach (var packageIdentity in context.Packages) { if (packagesToUninstall.Contains(packageIdentity)) { packagesToUninstall.Remove(packageIdentity); } else { packagesToInstall.Add(packageIdentity); } } var actions = new List <ResolvedAction>(packagesToUninstall.Select(ResolvedAction.CreateUninstall)); foreach (var packageIdentity in packagesToInstall) { actions.Add(ResolvedAction.CreateInstall(packageIdentity, context.PackageDependencies[packageIdentity].Source)); } return(actions); }
private GenericityType GetPrefixType(PackagesContext packagesContext, IContext context) { var prefixList = this.Objectexp.Symbol.GetExpressions(packagesContext, context); if (prefixList.Length != 1) { throw new SyntaxException("Cannot call function here.", this.Lparen.Line, this.Lparen.Column); } var prefix = prefixList[0]; if (prefix.Type == Type.Any || prefix.Type == Type.Table) { return(GenericityType.Any); } if (!(prefix.Type.Name == Type.Function.Name && prefix.Type.PackageName == Type.Function.PackageName)) { throw new SyntaxException("Cannot call function here.", this.Lparen.Line, this.Lparen.Column); } var tlGenericityType = prefix.Type as GenericityType; if (tlGenericityType == null) { throw new SyntaxException("Cannot call function here.", this.Lparen.Line, this.Lparen.Column); } return(tlGenericityType); }
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { return(this.GetExpressions(new Expression() { Classify = ExpressionType.This, Type = expContext.ClassContext.GetTLType() })); }
public override Type GetTLType(PackagesContext packagesContext) { if (packagesContext == null) { return(new Type(this.Identifier.Symbol, null, TypeCategory.Class)); } return(packagesContext.GetTLType(this.Identifier.Symbol)); }
public Expression[] GetExpressions(PackagesContext packagesContext, IContext expContext) { if (this.Expressions == null) { this.Expressions = this.OnGetExpressions(packagesContext, expContext); } return(this.Expressions); }
public Type[] GetReturnValues(PackagesContext packagesContext, IContext expContext) { if (this.returnValues != null) { return(this.returnValues); } this.returnValues = this.OnGetReturnValues(packagesContext, expContext); return(this.returnValues); }
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { var functionContext = this.Functionbody.Symbol.GetFunctionContext(expContext); return(this.GetExpressions(new Expression() { Classify = ExpressionType.Value, Type = functionContext.Type, Element = functionContext })); }
public bool ExpTypeIs(Type type, PackagesContext packagesContext, IContext expContext) { var tlValues = this.GetExpressions(packagesContext, expContext); if (tlValues.Length == 1) { return(tlValues[0].Type == type); } return(false); }
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { var c = packagesContext.GetClass(this.Identifier.Symbol); if (c == null) { throw new SyntaxException(string.Format("Cannot resolve symbol {0}", this.Identifier.Symbol), this.Identifier.Line, this.Identifier.Column); } return(this.GetExpressionsWithValue(packagesContext.GetTLType(this.Identifier.Symbol))); }
public override bool BuildPackageContext(PackagesContext packages) { try { packages.Import(this.Packagename.Symbol.GetPackageName()); } catch (Exception e) { throw new SyntaxException(e.Message, this.Import.Line, this.Import.Column); } return(true); }
private void ClarifyType(Field field, PackagesContext packagesContext) { try { field.Type.ClarifyType(packagesContext); } catch (UnknowTypeException e) { var positionToken = field.DefineProduction.GetPositionToken(); throw new SyntaxException(e.Message, positionToken.Line, positionToken.Column); } }
public override Type[] GetTLType(PackagesContext packagesContext) { var tokens = this.Typelist.Symbol.GetTypes(new List <Token <Type_basisproduction> >()); Type[] types = new Type[tokens.Count]; for (int i = 0; i < tokens.Count; i++) { Token <Type_basisproduction> token = tokens[i]; types[i] = token.Symbol.GetTLType(packagesContext); } return(types); }
public Expression[] GetExpTypeWithHashTable( PackagesContext packagesContext, IContext expContext, GenericityType prefixType, Expression indexValue) { if (indexValue.Type != prefixType.FirstGroupGenericTypeArguments[0] || indexValue.Classify != ExpressionType.Value) { throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column); } return(this.GetExpressionsWithValue(prefixType.FirstGroupGenericTypeArguments[1])); }
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { var tlType = this.Type.Symbol.GetTLType(packagesContext); if (!tlType.IsDecidedType()) { var type = packagesContext.GetTLType(tlType.Name); tlType.PackageName = type.PackageName; tlType.Name = type.Name; } return(this.GetExpressionsWithValue(tlType)); }
public virtual void ClarifyType(PackagesContext packagesContext) { if (!this.IsDecidedType()) { var type = packagesContext.GetTLType(this.Name); if (type == null) { throw new UnknowTypeException(string.Format("Cannot find type '{0}' in {1}", this.Name, packagesContext.Class.ClassFullName)); } this.PackageName = type.PackageName; this.Name = type.Name; } }
public override Parameter[] GetParameters(PackagesContext packagesContext) { var @params = this.Parameterlist.Symbol.GetParams(new List <Token <Parameter_basisproduction> >()); Parameter[] tlParameters = new Parameter[@params.Count]; for (int i = 0; i < @params.Count; i++) { Token <Parameter_basisproduction> token = @params[i]; tlParameters[i] = token.Symbol.GetParameter(packagesContext); } return(tlParameters); }
public PackagesFileReader(IPackagesFilesLocator packagesFilesLocator, PackagesContext context, ISolutionFileLocator solutionFileLocator, IOptions <PackagesFileConfig> packagesFileConfig, IProjectFileLocator projectFileLocators, IPackageFeedReader packageFeedReader) { _packagesFilesLocator = packagesFilesLocator; _context = context; _solutionFileLocator = solutionFileLocator; _projectFileLocators = projectFileLocators; _packageFeedReader = packageFeedReader; _packagesFileConfig = packagesFileConfig.Value; }
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { var returnValues = this.Functioncall.Symbol.GetReturnValues(packagesContext, expContext); var tlValues = new Expression[returnValues.Length]; for (int i = 0; i < returnValues.Length; i++) { var returnValue = returnValues[i]; tlValues[i] = new Expression() { Classify = ExpressionType.Value, Type = returnValue }; } return(this.GetExpressions(tlValues)); }
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { var symbol = this.Identifier.Symbol; var t = packagesContext.GetTLType(symbol); if (t != null) { return(this.GetExpressionsWithClass(t)); } var contextElement = expContext.GetElementInParent(symbol, expContext); if (contextElement != null) { return(this.GetExpressionsWithValue(contextElement.Type)); } throw new SyntaxException(string.Format("Cannot resolve symbol '{0}'", this.Identifier.Symbol), this.Identifier.Line, this.Identifier.Column); }
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { var prefixList = this.Objectexp.Symbol.GetExpressions(packagesContext, expContext); if (prefixList.Length != 1) { throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column); } var prefix = prefixList[0]; if (prefix.Type == Type.Table || prefix.Type == Type.Any) { return(new[] { new Expression() { Classify = ExpressionType.Value, Type = Type.Any } }); } if (prefix.Classify != ExpressionType.Value) { throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column); } if (!(prefix.Type is GenericityType)) { throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column); } var prefixType = prefix.Type as GenericityType; var indexExpValue = this.Exp.Symbol.GetExpressions(packagesContext, expContext); if (indexExpValue.Length != 1) { throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column); } if (prefixType.Name == Type.ListTable.Name && prefixType.PackageName == Type.ListTable.PackageName) { return(this.GetExpTypeWithListTable(packagesContext, expContext, prefixType, indexExpValue[0])); } if (prefixType.Name == Type.HashTable.Name && prefixType.PackageName == Type.HashTable.PackageName) { return(this.GetExpTypeWithHashTable(packagesContext, expContext, prefixType, indexExpValue[0])); } throw new SyntaxException("Cannot resolve symbol here.", this.Lbracket.Line, this.Lbracket.Column); }
public override bool BuildPackageContext(PackagesContext packages) { try { packages.Import(packages.Class.PackageName); } catch (Exception e) { throw new SyntaxException(e.Message, this.Packagedec.Line, this.Packagedec.Column); } var importDecs = this.Importlist.Symbol.GetImportDecs(new List <Token <Import_dec_basisproduction> >()); foreach (var importDec in importDecs) { importDec.Symbol.BuildPackageContext(packages); } return(true); }
public override void ClarifyType(PackagesContext packagesContext) { if (!this.IsDecidedType()) { if (this.FirstGroupGenericTypeArguments != null) { foreach (var genericTypeArgument in this.FirstGroupGenericTypeArguments) { genericTypeArgument.ClarifyType(packagesContext); } } if (this.SecondGroupGenericTypeArguments != null) { foreach (var genericTypeArgument in this.SecondGroupGenericTypeArguments) { genericTypeArgument.ClarifyType(packagesContext); } } } base.ClarifyType(packagesContext); }
private void ClarifyType(Function function, PackagesContext packagesContext) { if (function == null) { return; } if (function.Parameters != null) { foreach (var parameter in function.Parameters) { parameter.Type.ClarifyType(packagesContext); } } if (function.ReturnValueTypes != null) { foreach (var returnValueType in function.ReturnValueTypes) { returnValueType.ClarifyType(packagesContext); } } }
private Expression[] GetExpTypeAsClass( PackagesContext packagesContext, IContext expContext, IContext targetContext) { var elementInParent = targetContext.GetElementInParent(this.MemberValue, expContext); if (elementInParent.ElementCategory == ContextElementCategory.Field) { var field = elementInParent as Field; if ((int)(field.Access & AccessType.Global) != 0) { throw new SyntaxException(string.Format("Cannot access global symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column); } if ((int)(field.Access & AccessType.Static) == 0) { throw new SyntaxException(string.Format("Cannot access non-static symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column); } return(this.GetExpressionsWithValue((elementInParent as Variable).Type)); } throw new SyntaxException(string.Format("Cannot resolve symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column); }
private Expression[] GetExpTypeAsVariable(PackagesContext packagesContext, IContext expContext, IContext targetContext) { var elementInParent = targetContext.GetElementInParent(this.MemberValue, expContext); if (elementInParent == null) { throw new SyntaxException(string.Format("Cannot access symbol '{0}' here.", this.MemberValue), this.Member.Line, this.Member.Column); } if (elementInParent.ElementCategory == ContextElementCategory.Variable || elementInParent.ElementCategory == ContextElementCategory.Parameter) { return(this.GetExpressionsWithValue(elementInParent.Type)); } if (elementInParent.ElementCategory == ContextElementCategory.Function) { var function = elementInParent as Function; if (function.ParentContext is Class) { if ((int)(function.Access & AccessType.Global) != 0) { throw new SyntaxException(string.Format("Cannot access global symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column); } } this.accessType = ":"; this.accessType = "."; return(this.GetExpressionsWithValue(elementInParent.Type)); } if (elementInParent.ElementCategory == ContextElementCategory.Field) { var field = elementInParent as Field; if ((int)(field.Access & AccessType.Global) != 0) { throw new SyntaxException(string.Format("Cannot access global symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column); } return(this.GetExpressionsWithValue(elementInParent.Type)); } throw new SyntaxException(string.Format("Cannot resolve symbol '{0}'", this.MemberValue), this.Member.Line, this.Member.Column); }
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { return(this.GetExpressionsWithValue(Type.Number)); }
protected override Expression[] OnGetExpressions(PackagesContext packagesContext, IContext expContext) { this.Equalityexp.Symbol.GetExpressions(packagesContext, expContext); this.Compareexp.Symbol.GetExpressions(packagesContext, expContext); return(this.GetExpressionsWithValue(Type.Bool)); }