Example #1
0
 public override void Repr(ReprBuilder builder) {
     // In Python 2.7, string literals in bytearray repr use the 3.x-style prefixed b'...' form.
     var langVer =
         builder.Options.LanguageVersion <= PythonLanguageVersion.V27 ?
         PythonLanguageVersion.V33 :
         builder.Options.LanguageVersion;
     var constExpr = new ConstantExpression(new AsciiString(ToBytes(), ToString()));
     builder.Append("bytearray(");
     builder.Append(constExpr.GetConstantRepr(langVer, escape8bitStrings: true));
     builder.Append(")");
 }
Example #2
0
 /// <summary>
 /// Appends <paramref name="value"/> represented as a Python literal.
 /// </summary>
 /// <remarks>
 /// Supports numeric types, booleans, and ASCII and Unicode strings. For integer types, representation depends on <see cref="HexadecimalDisplay"/>.
 /// </remarks>
 public ReprBuilder AppendLiteral(object value)
 {
     if (TryAppendDecOrHex(value))
     {
         if (value is BigInteger && Options.LanguageVersion <= PythonLanguageVersion.V27)
         {
             Append("L");
         }
     }
     else
     {
         var constExpr = new ConstantExpression(value);
         Append(constExpr.GetConstantRepr(Options.LanguageVersion, escape8bitStrings: true));
     }
     return(this);
 }
        private void GetFunctionDescription(FunctionDefinition def, Action <string, VSOBDESCRIPTIONSECTION, IVsNavInfo> addDescription)
        {
            addDescription(ScopeNode.Name, VSOBDESCRIPTIONSECTION.OBDS_NAME, null);
            addDescription("(", VSOBDESCRIPTIONSECTION.OBDS_MISC, null);

            for (int i = 0; i < def.Parameters.Count; i++)
            {
                if (i != 0)
                {
                    addDescription(", ", VSOBDESCRIPTIONSECTION.OBDS_MISC, null);
                }

                var curParam = def.Parameters[i];

                string name = curParam.Name;
                if (curParam.IsDictionary)
                {
                    name = "**" + name;
                }
                else if (curParam.IsList)
                {
                    name = "*" + curParam.Name;
                }

                if (curParam.DefaultValue != null)
                {
                    // TODO: Support all possible expressions for default values, we should
                    // probably have a PythonAst walker for expressions or we should add ToCodeString()
                    // onto Python ASTs so they can round trip
                    ConstantExpression defaultValue = curParam.DefaultValue as ConstantExpression;
                    if (defaultValue != null)
                    {
                        // FIXME: Use python repr
                        name = name + " = " + defaultValue.GetConstantRepr(def.GlobalParent.LanguageVersion);
                    }
                }

                addDescription(name, VSOBDESCRIPTIONSECTION.OBDS_PARAM, null);
            }
            addDescription(")\n", VSOBDESCRIPTIONSECTION.OBDS_MISC, null);
        }
Example #4
0
 internal static string GetDefaultValue(PythonAnalyzer state, Parameter curParam, PythonAst tree)
 {
     if (curParam.DefaultValue != null)
     {
         // TODO: Support all possible expressions for default values, we should
         // probably have a PythonAst walker for expressions or we should add ToCodeString()
         // onto Python ASTs so they can round trip
         ConstantExpression defaultValue = curParam.DefaultValue as ConstantExpression;
         if (defaultValue != null)
         {
             return(defaultValue.GetConstantRepr(state.LanguageVersion));
         }
         else
         {
             NameExpression nameExpr = curParam.DefaultValue as NameExpression;
             if (nameExpr != null)
             {
                 return(nameExpr.Name);
             }
             else
             {
                 DictionaryExpression dict = curParam.DefaultValue as DictionaryExpression;
                 if (dict != null)
                 {
                     if (dict.Items.Count == 0)
                     {
                         return("{}");
                     }
                     else
                     {
                         return("{...}");
                     }
                 }
                 else
                 {
                     ListExpression list = curParam.DefaultValue as ListExpression;
                     if (list != null)
                     {
                         if (list.Items.Count == 0)
                         {
                             return("[]");
                         }
                         else
                         {
                             return("[...]");
                         }
                     }
                     else
                     {
                         TupleExpression tuple = curParam.DefaultValue as TupleExpression;
                         if (tuple != null)
                         {
                             if (tuple.Items.Count == 0)
                             {
                                 return("()");
                             }
                             else
                             {
                                 return("(...)");
                             }
                         }
                         else
                         {
                             return(curParam.DefaultValue.ToCodeString(tree));
                         }
                     }
                 }
             }
         }
     }
     return(null);
 }