Ambiguity vs. context-sensitivity It is said that attributes supply some semantic information to the grammar. Meantime, the same attributes let you to resolve ambiguities. Text books agree that it is worth haveing a CF grammar which admits ambiguities because the ambiguities will go away anyway once you evaluate your AST with attributes anyway. For this reason it is useless to invent an intractable CS grammar for your language. 

This strongly associates ambiguities with context sensitivity in my mind. However, there is an expert in the field who states brazen faced that context sensitivity is absolutely irrelevant to ambiguity but supplies no support to ground his statement. Can you untangle the conflicting opinions by some light?



I cannot refrain from asking the same question in the following form. My mind is highly influenced by this description the of grammar type comparison in "Parsing Techniques: A Practical Guide"


  Type n grammars are more powerful than Type n+1 grammars, for n =
  0,1,2”, and one often reads statements like “A regular (Type 3)
  grammar is not powerful enough to match parentheses”. It means that
  more powerful grammars can define more complicated boundaries between
  correct and incorrect sentences. Some boundaries are so fine that they
  cannot be described by any grammar (that is, by any generative
  process). This idea has been depicted metaphorically in Figure 2.33,
  in which a rose is approximated by increasingly finer outlines. In
  this metaphor, the rose corresponds to the language (imagine the
  sentences of the language as molecules in the rose); the grammar
  serves to delineate its silhouette. A regular grammar only allows us
  straight horizontal and vertical line segments to describe the flower;
  the result is a coarse and mechanical-looking picture. A CF grammar
  would approximate the outline by straight lines at any angle and by
  circle segments. The result is stilted but recognizable. A CS grammar
  would present us with a smooth curve tightly enveloping the flower,
  but the curve is too smooth: it cannot follow all the sharp turns, and
  it deviates slightly at complicated points; still, a very realistic
  picture results. An unrestricted phrase structure grammar can
  represent the outline perfectly. The rose itself cannot be caught in a
  finite description; its essence remains forever out of our reach. 





  A
  more prosaic and practical example can be found in the successive sets
  of Java programs that can be generated by the various grammar types:
  
  
  The set of all lexically correct Java programs can be generated by a regular grammar. A Java program is lexically correct if there are no
  newlines inside strings, comments are terminated before end-of-file,
  all numerical constants have the right form, etc.
  The set of all syntactically correct Java programs can be generated by a context free grammar. These programs conform to the
  (CF) grammar in the manual.
  The set of all semantically correct Java programs can be generated by a CS grammar. These are the programs that pass through a Java
  compiler without error.
  The set of all Java programs that would terminate in finite time when run with a given input can be generated by an unrestricted phrase
  structure grammar. Such a grammar would incorporate detailed
  descriptions of the Java lib and the Java run-time system.
  The set of all Java programs that solve a given problem cannot be generated by a grammar (although the description of the set is
  finite).
  


I see that CF can generate the syntactically valid programs and you need CS grammar to accommodate the semantics of the language. This more complete grammar can resolve if x(y) is a call of a function or type conversion. It will also iron out the associativity ambiguity in a+b+c telling that difference between (a+b)+c and a+(b+c) is immaterial. For this reason I think that CF -> CS also resolves ambiguities. Why telling that context sensitivity and ambiguity are orthogonal after that?
This is plainly wrong. The set of all Java programs that always terminate is not recursively enumerable (essentially the halting problem), and so can't be generated by any grammar.

Ambiguous context free grammars are hard to parse efficiently, compiler writers prefer unambiguous grammars (or use tricks in the parser to bypass ambiguities). If the underlying grammar is ambiguous, chances are that the attributed grammar won't give a unique meaning either.

A context free grammar is called ambiguous if there is a string generated by the grammar with two different derivation trees. Context sensitive grammars don't have any similar description of the derivation that is independent of the order of productions applied, so ambiguity doesn't make sense for them.